mode.utils.collections — mode-ng 0.4.0 documentation

# `mode.utils.collections`

Custom data structures.

class mode.utils.collections.AttributeDict

  Dict subclass with attribute access.

class mode.utils.collections.AttributeDictMixin

  Mixin for Mapping interface that adds attribute access.

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

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

  Dict interface to attributes.

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

  get(k[, d]) → D[k] if k in D, else d. d defaults to None.
  obj: Any = None
  setdefault(k[, d]) → D.get(k,d), also set D[k]=d if k not in D

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.

  clear() → None. Remove all items from D.
  copy() → dict
  data: MutableMapping[KT, VT]
  classmethod fromkeys(iterable: Iterable[KT], value: Optional[VT] = None) → FastUserDict
  items() → a set-like object providing a view on D's items
  keys() → a set-like object providing a view on D's keys
  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

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

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

  Proxy to list.

class mode.utils.collections.FastUserSet

  Proxy to set.

  add(element: T) → None

    Add an element.

  clear() → None

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

  copy() → MutableSet[T]
  data: MutableSet[T]
  difference(other: Union[AbstractSet[T], Iterable[T]]) → MutableSet[T]
  difference_update(other: Union[AbstractSet[T], Iterable[T]]) → None
  discard(element: T) → None

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

  intersection(other: Union[AbstractSet[T], Iterable[T]]) → MutableSet[T]
  intersection_update(other: Union[AbstractSet[T], Iterable[T]]) → None
  isdisjoint(other: Iterable[T]) → bool

    Return True if two sets have a null intersection.

  issubset(other: AbstractSet[T]) → bool
  issuperset(other: AbstractSet[T]) → bool
  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(other: Union[AbstractSet[T], Iterable[T]]) → MutableSet[T]
  symmetric_difference_update(other: Union[AbstractSet[T], Iterable[T]]) → None
  union(other: Union[AbstractSet[T], Iterable[T]]) → MutableSet[T]
  update(other: Union[AbstractSet[T], Iterable[T]]) → None

class mode.utils.collections.Heap(data: Optional[Sequence[T]] = None)

  Generic interface to `heapq`.

  insert(index: int, object: T) → None

    S.insert(index, value) – insert value before index

  nlargest(n: int, key: Optional[Callable] = None) → list[T]

    Find the n largest elements in the dataset.

  nsmallest(n: int, key: Optional[Callable] = None) → list[T]

    Find the n smallest elements in the dataset.

  pop(index: int = 0) → T

    Pop the smallest item off the heap.

    Maintains the heap invariant.

  push(item: T) → None

    Push item onto heap, maintaining the heap invariant.

  pushpop(item: T) → T

    Push item on the heap, then pop and return from the heap.

    The combined action runs more efficiently than `push()` followed by a separate call to `pop()`.

  replace(item: T) → T

    Pop and return the current smallest value, and add the new item.

    This is more efficient than :meth`pop` followed by `push()`, and can be more appropriate when using a fixed-size heap.

    Note that the value returned may be larger than item! That constrains reasonable uses of this routine unless written as part of a conditional replacement:

        if item > heap[0]:
            item = heap.replace(item)

class mode.utils.collections.LRUCache(limit: Optional[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.

  data: OrderedDict
  incr(key: KT, delta: int = 1) → int
  items() → a set-like object providing a view on D's items
  keys() → a set-like object providing a view on D's keys
  limit: Optional[int]
  popitem() → (k, v), remove and return some (key, value) pair

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

  thread_safety: bool
  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

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

class mode.utils.collections.ManagedUserDict

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

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

    Handle that the mapping is being cleared.

  on_key_del(key: KT) → None

    Handle that a key is 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.

  raw_update(*args: Any, **kwargs: Any) → None
  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

class mode.utils.collections.ManagedUserSet

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

  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
  on_add(value: T) → None
  on_change(added: set[T], removed: set[T]) → None
  on_clear() → None
  on_discard(value: T) → None
  pop() → T

    Return the popped value. Raise KeyError if empty.

  raw_update(*args: Any, **kwargs: Any) → None
  symmetric_difference_update(other: Union[AbstractSet[T], Iterable[T]]) → None
  update(other: Union[AbstractSet[T], Iterable[T]]) → None

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

  Wrap object into supporting the mapping interface if necessary.