{
    "content": [
        {
            "type": "text",
            "text": "# _collections_abc (pydoc)\n\n**Summary:** collections.abc - Abstract Base Classes (ABCs) for collections, according to PEP 3119.\n\n## Section Outline\n\n- **NAME** (2 lines)\n- **MODULE REFERENCE** (8 lines)\n- **DESCRIPTION** (2 lines)\n- **CLASSES** (27 lines) — 25 subsections\n  - class AsyncGenerator (52 lines)\n  - class AsyncIterable (25 lines)\n  - class AsyncIterator (36 lines)\n  - class Awaitable (25 lines)\n  - class ByteString (63 lines)\n  - class Callable (30 lines)\n  - class Collection (45 lines)\n  - class Container (25 lines)\n  - class Coroutine (47 lines)\n  - class Generator (52 lines)\n  - class Hashable (21 lines)\n  - class ItemsView (96 lines)\n  - class Iterable (25 lines)\n  - class Iterator (36 lines)\n  - class KeysView (96 lines)\n  - class Mapping (73 lines)\n  - class MappingView (41 lines)\n  - class MutableMapping (105 lines)\n  - class MutableSequence (96 lines)\n  - class MutableSet (126 lines)\n  - class Reversible (38 lines)\n  - class Sequence (63 lines)\n  - class Set (95 lines)\n  - class Sized (20 lines)\n  - class ValuesView (52 lines)\n- **DATA** (2 lines)\n- **FILE** (3 lines)\n\n## Full Content\n\n### NAME\n\ncollections.abc - Abstract Base Classes (ABCs) for collections, according to PEP 3119.\n\n### MODULE REFERENCE\n\nhttps://docs.python.org/3.10/library/collections.abc.html\n\nThe following documentation is automatically generated from the Python\nsource files.  It may be incomplete, incorrect or include features that\nare considered implementation detail and may vary between Python\nimplementations.  When in doubt, consult the module reference at the\nlocation listed above.\n\n### DESCRIPTION\n\nUnit tests are in testcollections.\n\n### CLASSES\n\nbuiltins.object\nAsyncIterable\nAsyncIterator\nAsyncGenerator\nAwaitable\nCoroutine\nCallable\nContainer\nHashable\nIterable\nIterator\nGenerator\nReversible\nSequence(Reversible, Collection)\nByteString\nMutableSequence\nSized\nCollection(Sized, Iterable, Container)\nMapping\nMutableMapping\nSet\nMutableSet\nMappingView\nItemsView(MappingView, Set)\nKeysView(MappingView, Set)\nValuesView(MappingView, Collection)\n\n#### class AsyncGenerator\n\n|  Method resolution order:\n|      AsyncGenerator\n|      AsyncIterator\n|      AsyncIterable\n|      builtins.object\n|\n|  Methods defined here:\n|\n|  async anext(self)\n|      Return the next item from the asynchronous generator.\n|      When exhausted, raise StopAsyncIteration.\n|\n|  async aclose(self)\n|      Raise GeneratorExit inside coroutine.\n|\n|  async asend(self, value)\n|      Send a value into the asynchronous generator.\n|      Return next yielded value or raise StopAsyncIteration.\n|\n|  async athrow(self, typ, val=None, tb=None)\n|      Raise an exception in the asynchronous generator.\n|      Return next yielded value or raise StopAsyncIteration.\n|\n|  ----------------------------------------------------------------------\n|  Class methods defined here:\n|\n|  subclasshook(C) from abc.ABCMeta\n|      Abstract classes can override this to customize issubclass().\n|\n|      This is invoked early on by abc.ABCMeta.subclasscheck().\n|      It should return True, False or NotImplemented.  If it returns\n|      NotImplemented, the normal algorithm is used.  Otherwise, it\n|      overrides the normal algorithm (and the outcome is cached).\n|\n|  ----------------------------------------------------------------------\n|  Data and other attributes defined here:\n|\n|  abstractmethods = frozenset({'asend', 'athrow'})\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from AsyncIterator:\n|\n|  aiter(self)\n|\n|  ----------------------------------------------------------------------\n|  Class methods inherited from AsyncIterable:\n|\n|  classgetitem = GenericAlias(...) from abc.ABCMeta\n|      Represent a PEP 585 generic type\n|\n|      E.g. for t = list[int], t.origin is list and t.args is (int,).\n\n#### class AsyncIterable\n\n|  Methods defined here:\n|\n|  aiter(self)\n|\n|  ----------------------------------------------------------------------\n|  Class methods defined here:\n|\n|  classgetitem = GenericAlias(...) from abc.ABCMeta\n|      Represent a PEP 585 generic type\n|\n|      E.g. for t = list[int], t.origin is list and t.args is (int,).\n|\n|  subclasshook(C) from abc.ABCMeta\n|      Abstract classes can override this to customize issubclass().\n|\n|      This is invoked early on by abc.ABCMeta.subclasscheck().\n|      It should return True, False or NotImplemented.  If it returns\n|      NotImplemented, the normal algorithm is used.  Otherwise, it\n|      overrides the normal algorithm (and the outcome is cached).\n|\n|  ----------------------------------------------------------------------\n|  Data and other attributes defined here:\n|\n|  abstractmethods = frozenset({'aiter'})\n\n#### class AsyncIterator\n\n|  Method resolution order:\n|      AsyncIterator\n|      AsyncIterable\n|      builtins.object\n|\n|  Methods defined here:\n|\n|  aiter(self)\n|\n|  async anext(self)\n|      Return the next item or raise StopAsyncIteration when exhausted.\n|\n|  ----------------------------------------------------------------------\n|  Class methods defined here:\n|\n|  subclasshook(C) from abc.ABCMeta\n|      Abstract classes can override this to customize issubclass().\n|\n|      This is invoked early on by abc.ABCMeta.subclasscheck().\n|      It should return True, False or NotImplemented.  If it returns\n|      NotImplemented, the normal algorithm is used.  Otherwise, it\n|      overrides the normal algorithm (and the outcome is cached).\n|\n|  ----------------------------------------------------------------------\n|  Data and other attributes defined here:\n|\n|  abstractmethods = frozenset({'anext'})\n|\n|  ----------------------------------------------------------------------\n|  Class methods inherited from AsyncIterable:\n|\n|  classgetitem = GenericAlias(...) from abc.ABCMeta\n|      Represent a PEP 585 generic type\n|\n|      E.g. for t = list[int], t.origin is list and t.args is (int,).\n\n#### class Awaitable\n\n|  Methods defined here:\n|\n|  await(self)\n|\n|  ----------------------------------------------------------------------\n|  Class methods defined here:\n|\n|  classgetitem = GenericAlias(...) from abc.ABCMeta\n|      Represent a PEP 585 generic type\n|\n|      E.g. for t = list[int], t.origin is list and t.args is (int,).\n|\n|  subclasshook(C) from abc.ABCMeta\n|      Abstract classes can override this to customize issubclass().\n|\n|      This is invoked early on by abc.ABCMeta.subclasscheck().\n|      It should return True, False or NotImplemented.  If it returns\n|      NotImplemented, the normal algorithm is used.  Otherwise, it\n|      overrides the normal algorithm (and the outcome is cached).\n|\n|  ----------------------------------------------------------------------\n|  Data and other attributes defined here:\n|\n|  abstractmethods = frozenset({'await'})\n\n#### class ByteString\n\n|  This unifies bytes and bytearray.\n|\n|  XXX Should add all their methods.\n|\n|  Method resolution order:\n|      ByteString\n|      Sequence\n|      Reversible\n|      Collection\n|      Sized\n|      Iterable\n|      Container\n|      builtins.object\n|\n|  Data and other attributes defined here:\n|\n|  abstractmethods = frozenset({'getitem', 'len'})\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from Sequence:\n|\n|  contains(self, value)\n|\n|  getitem(self, index)\n|\n|  iter(self)\n|\n|  reversed(self)\n|\n|  count(self, value)\n|      S.count(value) -> integer -- return number of occurrences of value\n|\n|  index(self, value, start=0, stop=None)\n|      S.index(value, [start, [stop]]) -> integer -- return first index of value.\n|      Raises ValueError if the value is not present.\n|\n|      Supporting start and stop arguments is optional, but\n|      recommended.\n|\n|  ----------------------------------------------------------------------\n|  Class methods inherited from Reversible:\n|\n|  subclasshook(C) from abc.ABCMeta\n|      Abstract classes can override this to customize issubclass().\n|\n|      This is invoked early on by abc.ABCMeta.subclasscheck().\n|      It should return True, False or NotImplemented.  If it returns\n|      NotImplemented, the normal algorithm is used.  Otherwise, it\n|      overrides the normal algorithm (and the outcome is cached).\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from Sized:\n|\n|  len(self)\n|\n|  ----------------------------------------------------------------------\n|  Class methods inherited from Iterable:\n|\n|  classgetitem = GenericAlias(...) from abc.ABCMeta\n|      Represent a PEP 585 generic type\n|\n|      E.g. for t = list[int], t.origin is list and t.args is (int,).\n\n#### class Callable\n\n|  Methods defined here:\n|\n|  call(self, *args, kwds)\n|      Call self as a function.\n|\n|  ----------------------------------------------------------------------\n|  Class methods defined here:\n|\n|  classgetitem = CallableGenericAlias(args) from abc.ABCMeta\n|      Represent `Callable[argtypes, resulttype]`.\n|\n|      This sets ``args`` to a tuple containing the flattened ``argtypes``\n|      followed by ``resulttype``.\n|\n|      Example: ``Callable[[int, str], float]`` sets ``args`` to\n|      ``(int, str, float)``.\n|\n|  subclasshook(C) from abc.ABCMeta\n|      Abstract classes can override this to customize issubclass().\n|\n|      This is invoked early on by abc.ABCMeta.subclasscheck().\n|      It should return True, False or NotImplemented.  If it returns\n|      NotImplemented, the normal algorithm is used.  Otherwise, it\n|      overrides the normal algorithm (and the outcome is cached).\n|\n|  ----------------------------------------------------------------------\n|  Data and other attributes defined here:\n|\n|  abstractmethods = frozenset({'call'})\n\n#### class Collection\n\n|  Method resolution order:\n|      Collection\n|      Sized\n|      Iterable\n|      Container\n|      builtins.object\n|\n|  Class methods defined here:\n|\n|  subclasshook(C) from abc.ABCMeta\n|      Abstract classes can override this to customize issubclass().\n|\n|      This is invoked early on by abc.ABCMeta.subclasscheck().\n|      It should return True, False or NotImplemented.  If it returns\n|      NotImplemented, the normal algorithm is used.  Otherwise, it\n|      overrides the normal algorithm (and the outcome is cached).\n|\n|  ----------------------------------------------------------------------\n|  Data and other attributes defined here:\n|\n|  abstractmethods = frozenset({'contains', 'iter', 'len'...\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from Sized:\n|\n|  len(self)\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from Iterable:\n|\n|  iter(self)\n|\n|  ----------------------------------------------------------------------\n|  Class methods inherited from Iterable:\n|\n|  classgetitem = GenericAlias(...) from abc.ABCMeta\n|      Represent a PEP 585 generic type\n|\n|      E.g. for t = list[int], t.origin is list and t.args is (int,).\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from Container:\n|\n|  contains(self, x)\n\n#### class Container\n\n|  Methods defined here:\n|\n|  contains(self, x)\n|\n|  ----------------------------------------------------------------------\n|  Class methods defined here:\n|\n|  classgetitem = GenericAlias(...) from abc.ABCMeta\n|      Represent a PEP 585 generic type\n|\n|      E.g. for t = list[int], t.origin is list and t.args is (int,).\n|\n|  subclasshook(C) from abc.ABCMeta\n|      Abstract classes can override this to customize issubclass().\n|\n|      This is invoked early on by abc.ABCMeta.subclasscheck().\n|      It should return True, False or NotImplemented.  If it returns\n|      NotImplemented, the normal algorithm is used.  Otherwise, it\n|      overrides the normal algorithm (and the outcome is cached).\n|\n|  ----------------------------------------------------------------------\n|  Data and other attributes defined here:\n|\n|  abstractmethods = frozenset({'contains'})\n\n#### class Coroutine\n\n|  Method resolution order:\n|      Coroutine\n|      Awaitable\n|      builtins.object\n|\n|  Methods defined here:\n|\n|  close(self)\n|      Raise GeneratorExit inside coroutine.\n|\n|  send(self, value)\n|      Send a value into the coroutine.\n|      Return next yielded value or raise StopIteration.\n|\n|  throw(self, typ, val=None, tb=None)\n|      Raise an exception in the coroutine.\n|      Return next yielded value or raise StopIteration.\n|\n|  ----------------------------------------------------------------------\n|  Class methods defined here:\n|\n|  subclasshook(C) from abc.ABCMeta\n|      Abstract classes can override this to customize issubclass().\n|\n|      This is invoked early on by abc.ABCMeta.subclasscheck().\n|      It should return True, False or NotImplemented.  If it returns\n|      NotImplemented, the normal algorithm is used.  Otherwise, it\n|      overrides the normal algorithm (and the outcome is cached).\n|\n|  ----------------------------------------------------------------------\n|  Data and other attributes defined here:\n|\n|  abstractmethods = frozenset({'await', 'send', 'throw'})\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from Awaitable:\n|\n|  await(self)\n|\n|  ----------------------------------------------------------------------\n|  Class methods inherited from Awaitable:\n|\n|  classgetitem = GenericAlias(...) from abc.ABCMeta\n|      Represent a PEP 585 generic type\n|\n|      E.g. for t = list[int], t.origin is list and t.args is (int,).\n\n#### class Generator\n\n|  Method resolution order:\n|      Generator\n|      Iterator\n|      Iterable\n|      builtins.object\n|\n|  Methods defined here:\n|\n|  next(self)\n|      Return the next item from the generator.\n|      When exhausted, raise StopIteration.\n|\n|  close(self)\n|      Raise GeneratorExit inside generator.\n|\n|  send(self, value)\n|      Send a value into the generator.\n|      Return next yielded value or raise StopIteration.\n|\n|  throw(self, typ, val=None, tb=None)\n|      Raise an exception in the generator.\n|      Return next yielded value or raise StopIteration.\n|\n|  ----------------------------------------------------------------------\n|  Class methods defined here:\n|\n|  subclasshook(C) from abc.ABCMeta\n|      Abstract classes can override this to customize issubclass().\n|\n|      This is invoked early on by abc.ABCMeta.subclasscheck().\n|      It should return True, False or NotImplemented.  If it returns\n|      NotImplemented, the normal algorithm is used.  Otherwise, it\n|      overrides the normal algorithm (and the outcome is cached).\n|\n|  ----------------------------------------------------------------------\n|  Data and other attributes defined here:\n|\n|  abstractmethods = frozenset({'send', 'throw'})\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from Iterator:\n|\n|  iter(self)\n|\n|  ----------------------------------------------------------------------\n|  Class methods inherited from Iterable:\n|\n|  classgetitem = GenericAlias(...) from abc.ABCMeta\n|      Represent a PEP 585 generic type\n|\n|      E.g. for t = list[int], t.origin is list and t.args is (int,).\n\n#### class Hashable\n\n|  Methods defined here:\n|\n|  hash(self)\n|      Return hash(self).\n|\n|  ----------------------------------------------------------------------\n|  Class methods defined here:\n|\n|  subclasshook(C) from abc.ABCMeta\n|      Abstract classes can override this to customize issubclass().\n|\n|      This is invoked early on by abc.ABCMeta.subclasscheck().\n|      It should return True, False or NotImplemented.  If it returns\n|      NotImplemented, the normal algorithm is used.  Otherwise, it\n|      overrides the normal algorithm (and the outcome is cached).\n|\n|  ----------------------------------------------------------------------\n|  Data and other attributes defined here:\n|\n|  abstractmethods = frozenset({'hash'})\n\n#### class ItemsView\n\n|  ItemsView(mapping)\n|\n|  Method resolution order:\n|      ItemsView\n|      MappingView\n|      Set\n|      Collection\n|      Sized\n|      Iterable\n|      Container\n|      builtins.object\n|\n|  Methods defined here:\n|\n|  contains(self, item)\n|\n|  iter(self)\n|\n|  ----------------------------------------------------------------------\n|  Data and other attributes defined here:\n|\n|  abstractmethods = frozenset()\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from MappingView:\n|\n|  init(self, mapping)\n|      Initialize self.  See help(type(self)) for accurate signature.\n|\n|  len(self)\n|\n|  repr(self)\n|      Return repr(self).\n|\n|  ----------------------------------------------------------------------\n|  Class methods inherited from MappingView:\n|\n|  classgetitem = GenericAlias(...) from abc.ABCMeta\n|      Represent a PEP 585 generic type\n|\n|      E.g. for t = list[int], t.origin is list and t.args is (int,).\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from Set:\n|\n|  and(self, other)\n|\n|  eq(self, other)\n|      Return self==value.\n|\n|  ge(self, other)\n|      Return self>=value.\n|\n|  gt(self, other)\n|      Return self>value.\n|\n|  le(self, other)\n|      Return self<=value.\n|\n|  lt(self, other)\n|      Return self<value.\n|\n|  or(self, other)\n|      Return self|value.\n|\n|  rand = and(self, other)\n|\n|  ror = or(self, other)\n|\n|  rsub(self, other)\n|\n|  rxor = xor(self, other)\n|\n|  sub(self, other)\n|\n|  xor(self, other)\n|\n|  isdisjoint(self, other)\n|      Return True if two sets have a null intersection.\n|\n|  ----------------------------------------------------------------------\n|  Data and other attributes inherited from Set:\n|\n|  hash = None\n|\n|  ----------------------------------------------------------------------\n|  Class methods inherited from Collection:\n|\n|  subclasshook(C) from abc.ABCMeta\n|      Abstract classes can override this to customize issubclass().\n|\n|      This is invoked early on by abc.ABCMeta.subclasscheck().\n|      It should return True, False or NotImplemented.  If it returns\n|      NotImplemented, the normal algorithm is used.  Otherwise, it\n|      overrides the normal algorithm (and the outcome is cached).\n\n#### class Iterable\n\n|  Methods defined here:\n|\n|  iter(self)\n|\n|  ----------------------------------------------------------------------\n|  Class methods defined here:\n|\n|  classgetitem = GenericAlias(...) from abc.ABCMeta\n|      Represent a PEP 585 generic type\n|\n|      E.g. for t = list[int], t.origin is list and t.args is (int,).\n|\n|  subclasshook(C) from abc.ABCMeta\n|      Abstract classes can override this to customize issubclass().\n|\n|      This is invoked early on by abc.ABCMeta.subclasscheck().\n|      It should return True, False or NotImplemented.  If it returns\n|      NotImplemented, the normal algorithm is used.  Otherwise, it\n|      overrides the normal algorithm (and the outcome is cached).\n|\n|  ----------------------------------------------------------------------\n|  Data and other attributes defined here:\n|\n|  abstractmethods = frozenset({'iter'})\n\n#### class Iterator\n\n|  Method resolution order:\n|      Iterator\n|      Iterable\n|      builtins.object\n|\n|  Methods defined here:\n|\n|  iter(self)\n|\n|  next(self)\n|      Return the next item from the iterator. When exhausted, raise StopIteration\n|\n|  ----------------------------------------------------------------------\n|  Class methods defined here:\n|\n|  subclasshook(C) from abc.ABCMeta\n|      Abstract classes can override this to customize issubclass().\n|\n|      This is invoked early on by abc.ABCMeta.subclasscheck().\n|      It should return True, False or NotImplemented.  If it returns\n|      NotImplemented, the normal algorithm is used.  Otherwise, it\n|      overrides the normal algorithm (and the outcome is cached).\n|\n|  ----------------------------------------------------------------------\n|  Data and other attributes defined here:\n|\n|  abstractmethods = frozenset({'next'})\n|\n|  ----------------------------------------------------------------------\n|  Class methods inherited from Iterable:\n|\n|  classgetitem = GenericAlias(...) from abc.ABCMeta\n|      Represent a PEP 585 generic type\n|\n|      E.g. for t = list[int], t.origin is list and t.args is (int,).\n\n#### class KeysView\n\n|  KeysView(mapping)\n|\n|  Method resolution order:\n|      KeysView\n|      MappingView\n|      Set\n|      Collection\n|      Sized\n|      Iterable\n|      Container\n|      builtins.object\n|\n|  Methods defined here:\n|\n|  contains(self, key)\n|\n|  iter(self)\n|\n|  ----------------------------------------------------------------------\n|  Data and other attributes defined here:\n|\n|  abstractmethods = frozenset()\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from MappingView:\n|\n|  init(self, mapping)\n|      Initialize self.  See help(type(self)) for accurate signature.\n|\n|  len(self)\n|\n|  repr(self)\n|      Return repr(self).\n|\n|  ----------------------------------------------------------------------\n|  Class methods inherited from MappingView:\n|\n|  classgetitem = GenericAlias(...) from abc.ABCMeta\n|      Represent a PEP 585 generic type\n|\n|      E.g. for t = list[int], t.origin is list and t.args is (int,).\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from Set:\n|\n|  and(self, other)\n|\n|  eq(self, other)\n|      Return self==value.\n|\n|  ge(self, other)\n|      Return self>=value.\n|\n|  gt(self, other)\n|      Return self>value.\n|\n|  le(self, other)\n|      Return self<=value.\n|\n|  lt(self, other)\n|      Return self<value.\n|\n|  or(self, other)\n|      Return self|value.\n|\n|  rand = and(self, other)\n|\n|  ror = or(self, other)\n|\n|  rsub(self, other)\n|\n|  rxor = xor(self, other)\n|\n|  sub(self, other)\n|\n|  xor(self, other)\n|\n|  isdisjoint(self, other)\n|      Return True if two sets have a null intersection.\n|\n|  ----------------------------------------------------------------------\n|  Data and other attributes inherited from Set:\n|\n|  hash = None\n|\n|  ----------------------------------------------------------------------\n|  Class methods inherited from Collection:\n|\n|  subclasshook(C) from abc.ABCMeta\n|      Abstract classes can override this to customize issubclass().\n|\n|      This is invoked early on by abc.ABCMeta.subclasscheck().\n|      It should return True, False or NotImplemented.  If it returns\n|      NotImplemented, the normal algorithm is used.  Otherwise, it\n|      overrides the normal algorithm (and the outcome is cached).\n\n#### class Mapping\n\n|  A Mapping is a generic container for associating key/value\n|  pairs.\n|\n|  This class provides concrete generic implementations of all\n|  methods except for getitem, iter, and len.\n|\n|  Method resolution order:\n|      Mapping\n|      Collection\n|      Sized\n|      Iterable\n|      Container\n|      builtins.object\n|\n|  Methods defined here:\n|\n|  contains(self, key)\n|\n|  eq(self, other)\n|      Return self==value.\n|\n|  getitem(self, key)\n|\n|  get(self, key, default=None)\n|      D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.\n|\n|  items(self)\n|      D.items() -> a set-like object providing a view on D's items\n|\n|  keys(self)\n|      D.keys() -> a set-like object providing a view on D's keys\n|\n|  values(self)\n|      D.values() -> an object providing a view on D's values\n|\n|  ----------------------------------------------------------------------\n|  Data and other attributes defined here:\n|\n|  abstractmethods = frozenset({'getitem', 'iter', 'len'}...\n|\n|  hash = None\n|\n|  reversed = None\n|\n|  ----------------------------------------------------------------------\n|  Class methods inherited from Collection:\n|\n|  subclasshook(C) from abc.ABCMeta\n|      Abstract classes can override this to customize issubclass().\n|\n|      This is invoked early on by abc.ABCMeta.subclasscheck().\n|      It should return True, False or NotImplemented.  If it returns\n|      NotImplemented, the normal algorithm is used.  Otherwise, it\n|      overrides the normal algorithm (and the outcome is cached).\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from Sized:\n|\n|  len(self)\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from Iterable:\n|\n|  iter(self)\n|\n|  ----------------------------------------------------------------------\n|  Class methods inherited from Iterable:\n|\n|  classgetitem = GenericAlias(...) from abc.ABCMeta\n|      Represent a PEP 585 generic type\n|\n|      E.g. for t = list[int], t.origin is list and t.args is (int,).\n\n#### class MappingView\n\n|  MappingView(mapping)\n|\n|  Method resolution order:\n|      MappingView\n|      Sized\n|      builtins.object\n|\n|  Methods defined here:\n|\n|  init(self, mapping)\n|      Initialize self.  See help(type(self)) for accurate signature.\n|\n|  len(self)\n|\n|  repr(self)\n|      Return repr(self).\n|\n|  ----------------------------------------------------------------------\n|  Class methods defined here:\n|\n|  classgetitem = GenericAlias(...) from abc.ABCMeta\n|      Represent a PEP 585 generic type\n|\n|      E.g. for t = list[int], t.origin is list and t.args is (int,).\n|\n|  ----------------------------------------------------------------------\n|  Data and other attributes defined here:\n|\n|  abstractmethods = frozenset()\n|\n|  ----------------------------------------------------------------------\n|  Class methods inherited from Sized:\n|\n|  subclasshook(C) from abc.ABCMeta\n|      Abstract classes can override this to customize issubclass().\n|\n|      This is invoked early on by abc.ABCMeta.subclasscheck().\n|      It should return True, False or NotImplemented.  If it returns\n|      NotImplemented, the normal algorithm is used.  Otherwise, it\n|      overrides the normal algorithm (and the outcome is cached).\n\n#### class MutableMapping\n\n|  A MutableMapping is a generic container for associating\n|  key/value pairs.\n|\n|  This class provides concrete generic implementations of all\n|  methods except for getitem, setitem, delitem,\n|  iter, and len.\n|\n|  Method resolution order:\n|      MutableMapping\n|      Mapping\n|      Collection\n|      Sized\n|      Iterable\n|      Container\n|      builtins.object\n|\n|  Methods defined here:\n|\n|  delitem(self, key)\n|\n|  setitem(self, key, value)\n|\n|  clear(self)\n|      D.clear() -> None.  Remove all items from D.\n|\n|  pop(self, key, default=<object object at 0x7f1db197c190>)\n|      D.pop(k[,d]) -> v, remove specified key and return the corresponding value.\n|      If key is not found, d is returned if given, otherwise KeyError is raised.\n|\n|  popitem(self)\n|      D.popitem() -> (k, v), remove and return some (key, value) pair\n|      as a 2-tuple; but raise KeyError if D is empty.\n|\n|  setdefault(self, key, default=None)\n|      D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D\n|\n|  update(self, other=(), /, kwds)\n|      D.update([E, ]F) -> None.  Update D from mapping/iterable E and F.\n|      If E present and has a .keys() method, does:     for k in E: D[k] = E[k]\n|      If E present and lacks .keys() method, does:     for (k, v) in E: D[k] = v\n|      In either case, this is followed by: for k, v in F.items(): D[k] = v\n|\n|  ----------------------------------------------------------------------\n|  Data and other attributes defined here:\n|\n|  abstractmethods = frozenset({'delitem', 'getitem', 'iter...\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from Mapping:\n|\n|  contains(self, key)\n|\n|  eq(self, other)\n|      Return self==value.\n|\n|  getitem(self, key)\n|\n|  get(self, key, default=None)\n|      D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.\n|\n|  items(self)\n|      D.items() -> a set-like object providing a view on D's items\n|\n|  keys(self)\n|      D.keys() -> a set-like object providing a view on D's keys\n|\n|  values(self)\n|      D.values() -> an object providing a view on D's values\n|\n|  ----------------------------------------------------------------------\n|  Data and other attributes inherited from Mapping:\n|\n|  hash = None\n|\n|  reversed = None\n|\n|  ----------------------------------------------------------------------\n|  Class methods inherited from Collection:\n|\n|  subclasshook(C) from abc.ABCMeta\n|      Abstract classes can override this to customize issubclass().\n|\n|      This is invoked early on by abc.ABCMeta.subclasscheck().\n|      It should return True, False or NotImplemented.  If it returns\n|      NotImplemented, the normal algorithm is used.  Otherwise, it\n|      overrides the normal algorithm (and the outcome is cached).\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from Sized:\n|\n|  len(self)\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from Iterable:\n|\n|  iter(self)\n|\n|  ----------------------------------------------------------------------\n|  Class methods inherited from Iterable:\n|\n|  classgetitem = GenericAlias(...) from abc.ABCMeta\n|      Represent a PEP 585 generic type\n|\n|      E.g. for t = list[int], t.origin is list and t.args is (int,).\n\n#### class MutableSequence\n\n|  All the operations on a read-write sequence.\n|\n|  Concrete subclasses must provide new or init,\n|  getitem, setitem, delitem, len, and insert().\n|\n|  Method resolution order:\n|      MutableSequence\n|      Sequence\n|      Reversible\n|      Collection\n|      Sized\n|      Iterable\n|      Container\n|      builtins.object\n|\n|  Methods defined here:\n|\n|  delitem(self, index)\n|\n|  iadd(self, values)\n|\n|  setitem(self, index, value)\n|\n|  append(self, value)\n|      S.append(value) -- append value to the end of the sequence\n|\n|  clear(self)\n|      S.clear() -> None -- remove all items from S\n|\n|  extend(self, values)\n|      S.extend(iterable) -- extend sequence by appending elements from the iterable\n|\n|  insert(self, index, value)\n|      S.insert(index, value) -- insert value before index\n|\n|  pop(self, index=-1)\n|      S.pop([index]) -> item -- remove and return item at index (default last).\n|      Raise IndexError if list is empty or index is out of range.\n|\n|  remove(self, value)\n|      S.remove(value) -- remove first occurrence of value.\n|      Raise ValueError if the value is not present.\n|\n|  reverse(self)\n|      S.reverse() -- reverse *IN PLACE*\n|\n|  ----------------------------------------------------------------------\n|  Data and other attributes defined here:\n|\n|  abstractmethods = frozenset({'delitem', 'getitem', 'len...\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from Sequence:\n|\n|  contains(self, value)\n|\n|  getitem(self, index)\n|\n|  iter(self)\n|\n|  reversed(self)\n|\n|  count(self, value)\n|      S.count(value) -> integer -- return number of occurrences of value\n|\n|  index(self, value, start=0, stop=None)\n|      S.index(value, [start, [stop]]) -> integer -- return first index of value.\n|      Raises ValueError if the value is not present.\n|\n|      Supporting start and stop arguments is optional, but\n|      recommended.\n|\n|  ----------------------------------------------------------------------\n|  Class methods inherited from Reversible:\n|\n|  subclasshook(C) from abc.ABCMeta\n|      Abstract classes can override this to customize issubclass().\n|\n|      This is invoked early on by abc.ABCMeta.subclasscheck().\n|      It should return True, False or NotImplemented.  If it returns\n|      NotImplemented, the normal algorithm is used.  Otherwise, it\n|      overrides the normal algorithm (and the outcome is cached).\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from Sized:\n|\n|  len(self)\n|\n|  ----------------------------------------------------------------------\n|  Class methods inherited from Iterable:\n|\n|  classgetitem = GenericAlias(...) from abc.ABCMeta\n|      Represent a PEP 585 generic type\n|\n|      E.g. for t = list[int], t.origin is list and t.args is (int,).\n\n#### class MutableSet\n\n|  A mutable set is a finite, iterable container.\n|\n|  This class provides concrete generic implementations of all\n|  methods except for contains, iter, len,\n|  add(), and discard().\n|\n|  To override the comparisons (presumably for speed, as the\n|  semantics are fixed), all you have to do is redefine le and\n|  then the other operations will automatically follow suit.\n|\n|  Method resolution order:\n|      MutableSet\n|      Set\n|      Collection\n|      Sized\n|      Iterable\n|      Container\n|      builtins.object\n|\n|  Methods defined here:\n|\n|  iand(self, it)\n|\n|  ior(self, it)\n|\n|  isub(self, it)\n|\n|  ixor(self, it)\n|\n|  add(self, value)\n|      Add an element.\n|\n|  clear(self)\n|      This is slow (creates N new iterators!) but effective.\n|\n|  discard(self, value)\n|      Remove an element.  Do not raise an exception if absent.\n|\n|  pop(self)\n|      Return the popped value.  Raise KeyError if empty.\n|\n|  remove(self, value)\n|      Remove an element. If not a member, raise a KeyError.\n|\n|  ----------------------------------------------------------------------\n|  Data and other attributes defined here:\n|\n|  abstractmethods = frozenset({'contains', 'iter', 'len'...\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from Set:\n|\n|  and(self, other)\n|\n|  eq(self, other)\n|      Return self==value.\n|\n|  ge(self, other)\n|      Return self>=value.\n|\n|  gt(self, other)\n|      Return self>value.\n|\n|  le(self, other)\n|      Return self<=value.\n|\n|  lt(self, other)\n|      Return self<value.\n|\n|  or(self, other)\n|      Return self|value.\n|\n|  rand = and(self, other)\n|\n|  ror = or(self, other)\n|\n|  rsub(self, other)\n|\n|  rxor = xor(self, other)\n|\n|  sub(self, other)\n|\n|  xor(self, other)\n|\n|  isdisjoint(self, other)\n|      Return True if two sets have a null intersection.\n|\n|  ----------------------------------------------------------------------\n|  Data and other attributes inherited from Set:\n|\n|  hash = None\n|\n|  ----------------------------------------------------------------------\n|  Class methods inherited from Collection:\n|\n|  subclasshook(C) from abc.ABCMeta\n|      Abstract classes can override this to customize issubclass().\n|\n|      This is invoked early on by abc.ABCMeta.subclasscheck().\n|      It should return True, False or NotImplemented.  If it returns\n|      NotImplemented, the normal algorithm is used.  Otherwise, it\n|      overrides the normal algorithm (and the outcome is cached).\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from Sized:\n|\n|  len(self)\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from Iterable:\n|\n|  iter(self)\n|\n|  ----------------------------------------------------------------------\n|  Class methods inherited from Iterable:\n|\n|  classgetitem = GenericAlias(...) from abc.ABCMeta\n|      Represent a PEP 585 generic type\n|\n|      E.g. for t = list[int], t.origin is list and t.args is (int,).\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from Container:\n|\n|  contains(self, x)\n\n#### class Reversible\n\n|  Method resolution order:\n|      Reversible\n|      Iterable\n|      builtins.object\n|\n|  Methods defined here:\n|\n|  reversed(self)\n|\n|  ----------------------------------------------------------------------\n|  Class methods defined here:\n|\n|  subclasshook(C) from abc.ABCMeta\n|      Abstract classes can override this to customize issubclass().\n|\n|      This is invoked early on by abc.ABCMeta.subclasscheck().\n|      It should return True, False or NotImplemented.  If it returns\n|      NotImplemented, the normal algorithm is used.  Otherwise, it\n|      overrides the normal algorithm (and the outcome is cached).\n|\n|  ----------------------------------------------------------------------\n|  Data and other attributes defined here:\n|\n|  abstractmethods = frozenset({'iter', 'reversed'})\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from Iterable:\n|\n|  iter(self)\n|\n|  ----------------------------------------------------------------------\n|  Class methods inherited from Iterable:\n|\n|  classgetitem = GenericAlias(...) from abc.ABCMeta\n|      Represent a PEP 585 generic type\n|\n|      E.g. for t = list[int], t.origin is list and t.args is (int,).\n\n#### class Sequence\n\n|  All the operations on a read-only sequence.\n|\n|  Concrete subclasses must override new or init,\n|  getitem, and len.\n|\n|  Method resolution order:\n|      Sequence\n|      Reversible\n|      Collection\n|      Sized\n|      Iterable\n|      Container\n|      builtins.object\n|\n|  Methods defined here:\n|\n|  contains(self, value)\n|\n|  getitem(self, index)\n|\n|  iter(self)\n|\n|  reversed(self)\n|\n|  count(self, value)\n|      S.count(value) -> integer -- return number of occurrences of value\n|\n|  index(self, value, start=0, stop=None)\n|      S.index(value, [start, [stop]]) -> integer -- return first index of value.\n|      Raises ValueError if the value is not present.\n|\n|      Supporting start and stop arguments is optional, but\n|      recommended.\n|\n|  ----------------------------------------------------------------------\n|  Data and other attributes defined here:\n|\n|  abstractmethods = frozenset({'getitem', 'len'})\n|\n|  ----------------------------------------------------------------------\n|  Class methods inherited from Reversible:\n|\n|  subclasshook(C) from abc.ABCMeta\n|      Abstract classes can override this to customize issubclass().\n|\n|      This is invoked early on by abc.ABCMeta.subclasscheck().\n|      It should return True, False or NotImplemented.  If it returns\n|      NotImplemented, the normal algorithm is used.  Otherwise, it\n|      overrides the normal algorithm (and the outcome is cached).\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from Sized:\n|\n|  len(self)\n|\n|  ----------------------------------------------------------------------\n|  Class methods inherited from Iterable:\n|\n|  classgetitem = GenericAlias(...) from abc.ABCMeta\n|      Represent a PEP 585 generic type\n|\n|      E.g. for t = list[int], t.origin is list and t.args is (int,).\n\n#### class Set\n\n|  A set is a finite, iterable container.\n|\n|  This class provides concrete generic implementations of all\n|  methods except for contains, iter and len.\n|\n|  To override the comparisons (presumably for speed, as the\n|  semantics are fixed), redefine le and ge,\n|  then the other operations will automatically follow suit.\n|\n|  Method resolution order:\n|      Set\n|      Collection\n|      Sized\n|      Iterable\n|      Container\n|      builtins.object\n|\n|  Methods defined here:\n|\n|  and(self, other)\n|\n|  eq(self, other)\n|      Return self==value.\n|\n|  ge(self, other)\n|      Return self>=value.\n|\n|  gt(self, other)\n|      Return self>value.\n|\n|  le(self, other)\n|      Return self<=value.\n|\n|  lt(self, other)\n|      Return self<value.\n|\n|  or(self, other)\n|      Return self|value.\n|\n|  rand = and(self, other)\n|\n|  ror = or(self, other)\n|\n|  rsub(self, other)\n|\n|  rxor = xor(self, other)\n|\n|  sub(self, other)\n|\n|  xor(self, other)\n|\n|  isdisjoint(self, other)\n|      Return True if two sets have a null intersection.\n|\n|  ----------------------------------------------------------------------\n|  Data and other attributes defined here:\n|\n|  abstractmethods = frozenset({'contains', 'iter', 'len'...\n|\n|  hash = None\n|\n|  ----------------------------------------------------------------------\n|  Class methods inherited from Collection:\n|\n|  subclasshook(C) from abc.ABCMeta\n|      Abstract classes can override this to customize issubclass().\n|\n|      This is invoked early on by abc.ABCMeta.subclasscheck().\n|      It should return True, False or NotImplemented.  If it returns\n|      NotImplemented, the normal algorithm is used.  Otherwise, it\n|      overrides the normal algorithm (and the outcome is cached).\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from Sized:\n|\n|  len(self)\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from Iterable:\n|\n|  iter(self)\n|\n|  ----------------------------------------------------------------------\n|  Class methods inherited from Iterable:\n|\n|  classgetitem = GenericAlias(...) from abc.ABCMeta\n|      Represent a PEP 585 generic type\n|\n|      E.g. for t = list[int], t.origin is list and t.args is (int,).\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from Container:\n|\n|  contains(self, x)\n\n#### class Sized\n\n|  Methods defined here:\n|\n|  len(self)\n|\n|  ----------------------------------------------------------------------\n|  Class methods defined here:\n|\n|  subclasshook(C) from abc.ABCMeta\n|      Abstract classes can override this to customize issubclass().\n|\n|      This is invoked early on by abc.ABCMeta.subclasscheck().\n|      It should return True, False or NotImplemented.  If it returns\n|      NotImplemented, the normal algorithm is used.  Otherwise, it\n|      overrides the normal algorithm (and the outcome is cached).\n|\n|  ----------------------------------------------------------------------\n|  Data and other attributes defined here:\n|\n|  abstractmethods = frozenset({'len'})\n\n#### class ValuesView\n\n|  ValuesView(mapping)\n|\n|  Method resolution order:\n|      ValuesView\n|      MappingView\n|      Collection\n|      Sized\n|      Iterable\n|      Container\n|      builtins.object\n|\n|  Methods defined here:\n|\n|  contains(self, value)\n|\n|  iter(self)\n|\n|  ----------------------------------------------------------------------\n|  Data and other attributes defined here:\n|\n|  abstractmethods = frozenset()\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from MappingView:\n|\n|  init(self, mapping)\n|      Initialize self.  See help(type(self)) for accurate signature.\n|\n|  len(self)\n|\n|  repr(self)\n|      Return repr(self).\n|\n|  ----------------------------------------------------------------------\n|  Class methods inherited from MappingView:\n|\n|  classgetitem = GenericAlias(...) from abc.ABCMeta\n|      Represent a PEP 585 generic type\n|\n|      E.g. for t = list[int], t.origin is list and t.args is (int,).\n|\n|  ----------------------------------------------------------------------\n|  Class methods inherited from Collection:\n|\n|  subclasshook(C) from abc.ABCMeta\n|      Abstract classes can override this to customize issubclass().\n|\n|      This is invoked early on by abc.ABCMeta.subclasscheck().\n|      It should return True, False or NotImplemented.  If it returns\n|      NotImplemented, the normal algorithm is used.  Otherwise, it\n|      overrides the normal algorithm (and the outcome is cached).\n\n### DATA\n\nall = ['Awaitable', 'Coroutine', 'AsyncIterable', 'AsyncIterator',...\n\n### FILE\n\n/usr/lib/python3.10/collectionsabc.py\n\n"
        }
    ],
    "structuredContent": {
        "command": "_collections_abc",
        "section": "",
        "mode": "pydoc",
        "summary": "collections.abc - Abstract Base Classes (ABCs) for collections, according to PEP 3119.",
        "synopsis": null,
        "tldr_summary": null,
        "tldr_examples": [],
        "tldr_source": null,
        "flags": [],
        "examples": [],
        "see_also": [],
        "section_outline": [
            {
                "name": "NAME",
                "lines": 2,
                "subsections": []
            },
            {
                "name": "MODULE REFERENCE",
                "lines": 8,
                "subsections": []
            },
            {
                "name": "DESCRIPTION",
                "lines": 2,
                "subsections": []
            },
            {
                "name": "CLASSES",
                "lines": 27,
                "subsections": [
                    {
                        "name": "class AsyncGenerator",
                        "lines": 52
                    },
                    {
                        "name": "class AsyncIterable",
                        "lines": 25
                    },
                    {
                        "name": "class AsyncIterator",
                        "lines": 36
                    },
                    {
                        "name": "class Awaitable",
                        "lines": 25
                    },
                    {
                        "name": "class ByteString",
                        "lines": 63
                    },
                    {
                        "name": "class Callable",
                        "lines": 30
                    },
                    {
                        "name": "class Collection",
                        "lines": 45
                    },
                    {
                        "name": "class Container",
                        "lines": 25
                    },
                    {
                        "name": "class Coroutine",
                        "lines": 47
                    },
                    {
                        "name": "class Generator",
                        "lines": 52
                    },
                    {
                        "name": "class Hashable",
                        "lines": 21
                    },
                    {
                        "name": "class ItemsView",
                        "lines": 96
                    },
                    {
                        "name": "class Iterable",
                        "lines": 25
                    },
                    {
                        "name": "class Iterator",
                        "lines": 36
                    },
                    {
                        "name": "class KeysView",
                        "lines": 96
                    },
                    {
                        "name": "class Mapping",
                        "lines": 73
                    },
                    {
                        "name": "class MappingView",
                        "lines": 41
                    },
                    {
                        "name": "class MutableMapping",
                        "lines": 105
                    },
                    {
                        "name": "class MutableSequence",
                        "lines": 96
                    },
                    {
                        "name": "class MutableSet",
                        "lines": 126
                    },
                    {
                        "name": "class Reversible",
                        "lines": 38
                    },
                    {
                        "name": "class Sequence",
                        "lines": 63
                    },
                    {
                        "name": "class Set",
                        "lines": 95
                    },
                    {
                        "name": "class Sized",
                        "lines": 20
                    },
                    {
                        "name": "class ValuesView",
                        "lines": 52
                    }
                ]
            },
            {
                "name": "DATA",
                "lines": 2,
                "subsections": []
            },
            {
                "name": "FILE",
                "lines": 3,
                "subsections": []
            }
        ]
    }
}