mode.utils.collections

Custom data structures.

class mode.utils.collections.FastUserDict

Proxy to dict.

Like collection.UserDict but reimplements some methods for better performance when the underlying dictionary is a real dict.

classmethod fromkeys(iterable: Iterable[KT], value: VT = None) → mode.utils.collections.FastUserSet

copy() → dict

update([E, ]**F) → None. Update D from mapping/iterable E and F.

If E present and has a .keys() method, does: for k in E: D[k] = E[k] If E present and lacks .keys() method, does: for (k, v) in E: D[k] = v In either case, this is followed by: for k, v in F.items(): D[k] = v

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

items() → a set-like object providing a view on D's items

keys() → a set-like object providing a view on D's keys

values() → an object providing a view on D's values

class mode.utils.collections.FastUserSet

Proxy to set.

copy() → Set[T]

difference(other: Union[AbstractSet[T], Iterable[T]]) → Set[T]

intersection(other: Union[AbstractSet[T], Iterable[T]]) → Set[T]

isdisjoint(other: AbstractSet[T]) → bool

Return True if two sets have a null intersection.

issubset(other: AbstractSet[T]) → bool

issuperset(other: AbstractSet[T]) → bool

symmetric_difference(other: Union[AbstractSet[T], Iterable[T]]) → Set[T]

union(other: Union[AbstractSet[T], Iterable[T]]) → Set[T]

add(element: T) → None

Add an element.

clear() → None

This is slow (creates N new iterators!) but effective.

difference_update(other: Union[AbstractSet[T], Iterable[T]]) → None

discard(element: T) → None

Remove an element. Do not raise an exception if absent.

intersection_update(other: Union[AbstractSet[T], Iterable[T]]) → None

pop() → T

Return the popped value. Raise KeyError if empty.

remove(element: T) → None

Remove an element. If not a member, raise a KeyError.

symmetric_difference_update(other: Union[AbstractSet[T], Iterable[T]]) → None

update(other: Union[AbstractSet[T], Iterable[T]]) → None

class mode.utils.collections.FastUserList(initlist=None)

Proxy to list.

class mode.utils.collections.LRUCache(limit: int = None, *, thread_safety: bool = False)

LRU Cache implementation using a doubly linked list to track access.

Parameters

• limit (int) – The maximum number of keys to keep in the cache. When a new key is inserted and the limit has been exceeded, the Least Recently Used key will be discarded from the cache.

• thread_safety (bool) – Enable if multiple OS threads are going to access/mutate the cache.

update([E, ]**F) → None. Update D from mapping/iterable E and F.

If E present and has a .keys() method, does: for k in E: D[k] = E[k] If E present and lacks .keys() method, does: for (k, v) in E: D[k] = v In either case, this is followed by: for k, v in F.items(): D[k] = v

popitem() → (k, v), remove and return some (key, value) pair

as a 2-tuple; but raise KeyError if D is empty.

keys() → a set-like object providing a view on D's keys

values() → an object providing a view on D's values

items() → a set-like object providing a view on D's items

incr(key: KT, delta: int = 1) → int

class mode.utils.collections.ManagedUserSet

A MutableSet that adds callbacks for when keys are get/set/deleted.

on_add(value: T) → None

on_discard(value: T) → None

on_clear() → None

on_change(added: Set[T], removed: Set[T]) → None

add(element: T) → None

Add an element.

clear() → None

This is slow (creates N new iterators!) but effective.

discard(element: T) → None

Remove an element. Do not raise an exception if absent.

pop() → T

Return the popped value. Raise KeyError if empty.

raw_update(*args: Any, **kwargs: Any) → None

difference_update(other: Union[AbstractSet[T], Iterable[T]]) → None

intersection_update(other: Union[AbstractSet[T], Iterable[T]]) → None

symmetric_difference_update(other: Union[AbstractSet[T], Iterable[T]]) → None

update(other: Union[AbstractSet[T], Iterable[T]]) → None

class mode.utils.collections.ManagedUserDict

A UserDict that adds callbacks for when keys are get/set/deleted.

on_key_get(key: KT) → None

Handle that key is being retrieved.

on_key_set(key: KT, value: VT) → None

Handle that value for a key is being set.

on_key_del(key: KT) → None

Handle that a key is deleted.

on_clear() → None

Handle that the mapping is being cleared.

update([E, ]**F) → None. Update D from mapping/iterable E and F.

If E present and has a .keys() method, does: for k in E: D[k] = E[k] If E present and lacks .keys() method, does: for (k, v) in E: D[k] = v In either case, this is followed by: for k, v in F.items(): D[k] = v

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

raw_update(*args: Any, **kwargs: Any) → None

class mode.utils.collections.AttributeDictMixin

Mixin for Mapping interface that adds attribute access.

I.e., d.key -> d[key]).

class mode.utils.collections.AttributeDict

Dict subclass with attribute access.

class mode.utils.collections.DictAttribute(obj: Any)

Dict interface to attributes.

obj[k] -> obj.k obj[k] = val -> obj.k = val

obj = None

get(k[, d]) → D[k] if k in D, else d. d defaults to None.

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

mode.utils.collections.force_mapping(m: Any) → Mapping

Wrap object into supporting the mapping interface if necessary.