Admin

name	type	size	perms	modified	actions
[parent directory]
__pycache__/	dir	-	0755	2026-08-18 11:43:01
asyncio/	dir	-	0755	2026-08-18 11:43:01
collections/	dir	-	0755	2026-08-18 11:43:01
concurrent/	dir	-	0755	2026-08-18 11:43:01
config-3.12-x86_64-linux-gnu/	dir	-	0755	2026-08-19 09:42:59
ctypes/	dir	-	0755	2026-08-18 11:43:01
curses/	dir	-	0755	2026-08-18 11:43:01
dbm/	dir	-	0755	2026-08-18 11:43:01
email/	dir	-	0755	2026-08-18 11:43:01
encodings/	dir	-	0755	2026-08-18 11:43:01
ensurepip/	dir	-	0755	2026-08-18 11:43:02
html/	dir	-	0755	2026-08-18 11:43:02
http/	dir	-	0755	2026-08-18 11:43:02
importlib/	dir	-	0755	2026-08-18 11:43:02
json/	dir	-	0755	2026-08-18 11:43:02
lib-dynload/	dir	-	0755	2026-08-18 11:43:02
lib2to3/	dir	-	0755	2026-08-18 11:43:49
logging/	dir	-	0755	2026-08-18 11:43:02
multiprocessing/	dir	-	0755	2026-08-18 11:43:02
pydoc_data/	dir	-	0755	2026-08-18 11:43:02
re/	dir	-	0755	2026-08-18 11:43:02
site-packages/	dir	-	0755	2026-08-19 08:35:27
sqlite3/	dir	-	0755	2026-08-18 11:43:02
tomllib/	dir	-	0755	2026-08-18 11:43:02
unittest/	dir	-	0755	2026-08-18 11:43:02
urllib/	dir	-	0755	2026-08-18 11:43:02
venv/	dir	-	0755	2026-08-18 11:43:02
wsgiref/	dir	-	0755	2026-08-18 11:43:02
xml/	dir	-	0755	2026-08-18 11:43:02
xmlrpc/	dir	-	0755	2026-08-18 11:43:02
zipfile/	dir	-	0755	2026-08-18 11:43:02
zoneinfo/	dir	-	0755	2026-08-18 11:43:02
__future__.py	file	5,218 B	0644	2026-03-03 12:39:30	edit
__hello__.py	file	227 B	0644	2026-03-03 12:39:30	edit
_aix_support.py	file	4,021 B	0644	2026-03-03 12:39:30	edit
_collections_abc.py	file	32,089 B	0644	2026-03-03 12:39:30	edit
_compat_pickle.py	file	8,761 B	0644	2026-03-03 12:39:30	edit
_compression.py	file	5,681 B	0644	2026-03-03 12:39:30	edit
_markupbase.py	file	14,653 B	0644	2026-03-03 12:39:30	edit
_osx_support.py	file	22,023 B	0644	2026-03-03 12:39:30	edit
_py_abc.py	file	6,189 B	0644	2026-03-03 12:39:30	edit
_pydatetime.py	file	92,087 B	0644	2026-03-03 12:39:30	edit
_pydecimal.py	file	227,283 B	0644	2026-03-03 12:39:30	edit
_pyio.py	file	93,593 B	0644	2026-03-03 12:39:30	edit
_pylong.py	file	10,790 B	0644	2026-03-03 12:39:30	edit
_sitebuiltins.py	file	3,128 B	0644	2026-03-03 12:39:30	edit
_strptime.py	file	28,393 B	0644	2026-03-03 12:39:30	edit
_sysconfigdata__linux_x86_64-linux-gnu.py	file	69,090 B	0644	2026-07-10 00:00:00	edit
_threading_local.py	file	7,220 B	0644	2026-03-03 12:39:30	edit
_weakrefset.py	file	5,893 B	0644	2026-03-03 12:39:30	edit
abc.py	file	6,538 B	0644	2026-03-03 12:39:30	edit
aifc.py	file	34,211 B	0644	2026-03-03 12:39:30	edit
antigravity.py	file	500 B	0644	2026-03-03 12:39:30	edit
argparse.py	file	101,155 B	0644	2026-03-03 12:39:30	edit
ast.py	file	64,452 B	0644	2026-03-03 12:39:30	edit
base64.py	file	20,634 B	0755	2026-03-03 12:39:30	edit
bdb.py	file	33,573 B	0644	2026-03-03 12:39:30	edit
bisect.py	file	3,423 B	0644	2026-03-03 12:39:30	edit
bz2.py	file	11,847 B	0644	2026-03-03 12:39:30	edit
calendar.py	file	25,864 B	0644	2026-03-03 12:39:30	edit
cgi.py	file	34,418 B	0755	2026-03-03 12:39:30	edit
cgitb.py	file	12,421 B	0644	2026-03-03 12:39:30	edit
chunk.py	file	5,500 B	0644	2026-03-03 12:39:30	edit
cmd.py	file	14,873 B	0644	2026-03-03 12:39:30	edit
code.py	file	10,962 B	0644	2026-03-03 12:39:30	edit
codecs.py	file	36,870 B	0644	2026-03-03 12:39:30	edit
codeop.py	file	5,908 B	0644	2026-03-03 12:39:30	edit
colorsys.py	file	4,062 B	0644	2026-03-03 12:39:30	edit
compileall.py	file	20,507 B	0644	2026-03-03 12:39:30	edit
configparser.py	file	53,789 B	0644	2026-03-03 12:39:30	edit
contextlib.py	file	27,637 B	0644	2026-03-03 12:39:30	edit
contextvars.py	file	129 B	0644	2026-03-03 12:39:30	edit
copy.py	file	8,412 B	0644	2026-03-03 12:39:30	edit
copyreg.py	file	7,614 B	0644	2026-03-03 12:39:30	edit
cProfile.py	file	6,555 B	0755	2026-03-03 12:39:30	edit
crypt.py	file	3,913 B	0644	2026-03-03 12:39:30	edit
csv.py	file	16,386 B	0644	2026-03-03 12:39:30	edit
dataclasses.py	file	62,085 B	0644	2026-03-03 12:39:30	edit
datetime.py	file	268 B	0644	2026-03-03 12:39:30	edit
decimal.py	file	2,805 B	0644	2026-03-03 12:39:30	edit
difflib.py	file	83,368 B	0644	2026-03-03 12:39:30	edit
dis.py	file	30,227 B	0644	2026-03-03 12:39:30	edit
doctest.py	file	106,749 B	0644	2026-03-03 12:39:30	edit
enum.py	file	81,540 B	0644	2026-03-03 12:39:30	edit
filecmp.py	file	10,381 B	0644	2026-03-03 12:39:30	edit
fileinput.py	file	15,714 B	0644	2026-03-03 12:39:30	edit
fnmatch.py	file	5,999 B	0644	2026-03-03 12:39:30	edit
fractions.py	file	38,147 B	0644	2026-03-03 12:39:30	edit
ftplib.py	file	34,735 B	0644	2026-03-03 12:39:30	edit
functools.py	file	37,940 B	0644	2026-03-03 12:39:30	edit
genericpath.py	file	5,572 B	0644	2026-03-03 12:39:30	edit
getopt.py	file	7,488 B	0644	2026-03-03 12:39:30	edit
getpass.py	file	5,990 B	0644	2026-03-03 12:39:30	edit
gettext.py	file	21,320 B	0644	2026-03-03 12:39:30	edit
glob.py	file	8,732 B	0644	2026-03-03 12:39:30	edit
graphlib.py	file	9,648 B	0644	2026-03-03 12:39:30	edit
gzip.py	file	25,402 B	0644	2026-03-03 12:39:30	edit
hashlib.py	file	9,683 B	0644	2026-07-10 00:00:00	edit
heapq.py	file	23,024 B	0644	2026-03-03 12:39:30	edit
hmac.py	file	8,043 B	0644	2026-07-10 00:00:00	edit
imaplib.py	file	54,209 B	0644	2026-07-10 00:00:00	edit
imghdr.py	file	4,398 B	0644	2026-03-03 12:39:30	edit
inspect.py	file	127,125 B	0644	2026-03-03 12:39:30	edit
io.py	file	3,582 B	0644	2026-03-03 12:39:30	edit
ipaddress.py	file	81,414 B	0644	2026-03-03 12:39:30	edit
keyword.py	file	1,073 B	0644	2026-03-03 12:39:30	edit
LICENSE.txt	file	13,936 B	0644	2026-03-03 12:39:30	edit
linecache.py	file	5,800 B	0644	2026-03-03 12:39:30	edit
locale.py	file	78,599 B	0644	2026-03-03 12:39:30	edit
lzma.py	file	13,277 B	0644	2026-03-03 12:39:30	edit
mailbox.py	file	78,911 B	0644	2026-03-03 12:39:30	edit
mailcap.py	file	9,333 B	0644	2026-03-03 12:39:30	edit
mimetypes.py	file	23,037 B	0644	2026-03-03 12:39:30	edit
modulefinder.py	file	23,699 B	0644	2026-03-03 12:39:30	edit
netrc.py	file	6,922 B	0644	2026-03-03 12:39:30	edit
nntplib.py	file	41,087 B	0644	2026-03-03 12:39:30	edit
ntpath.py	file	30,404 B	0644	2026-03-03 12:39:30	edit
nturl2path.py	file	2,374 B	0644	2026-03-03 12:39:30	edit
numbers.py	file	11,467 B	0644	2026-03-03 12:39:30	edit
opcode.py	file	13,174 B	0644	2026-03-03 12:39:30	edit
operator.py	file	10,965 B	0644	2026-03-03 12:39:30	edit
optparse.py	file	60,369 B	0644	2026-03-03 12:39:30	edit
os.py	file	40,821 B	0644	2026-03-03 12:39:30	edit
pathlib.py	file	51,052 B	0644	2026-03-03 12:39:30	edit
pdb.py	file	70,297 B	0755	2026-03-03 12:39:30	edit
pickle.py	file	66,911 B	0644	2026-03-03 12:39:30	edit
pickletools.py	file	94,052 B	0644	2026-03-03 12:39:30	edit
pipes.py	file	8,978 B	0644	2026-03-03 12:39:30	edit
pkgutil.py	file	18,281 B	0644	2026-03-03 12:39:30	edit
platform.py	file	43,388 B	0755	2026-03-03 12:39:30	edit
plistlib.py	file	28,582 B	0644	2026-03-03 12:39:30	edit
poplib.py	file	14,742 B	0644	2026-07-10 00:00:00	edit
posixpath.py	file	17,356 B	0644	2026-03-03 12:39:30	edit
pprint.py	file	24,158 B	0644	2026-03-03 12:39:30	edit
profile.py	file	23,092 B	0755	2026-03-03 12:39:30	edit
pstats.py	file	29,289 B	0644	2026-03-03 12:39:30	edit
pty.py	file	6,137 B	0644	2026-03-03 12:39:30	edit
py_compile.py	file	7,837 B	0644	2026-03-03 12:39:30	edit
pyclbr.py	file	11,396 B	0644	2026-03-03 12:39:30	edit
pydoc.py	file	113,508 B	0755	2026-03-03 12:39:30	edit
queue.py	file	11,496 B	0644	2026-03-03 12:39:30	edit
quopri.py	file	7,183 B	0755	2026-03-03 12:39:30	edit
random.py	file	34,689 B	0644	2026-03-03 12:39:30	edit
reprlib.py	file	7,148 B	0644	2026-03-03 12:39:30	edit
rlcompleter.py	file	7,827 B	0644	2026-03-03 12:39:30	edit
runpy.py	file	12,885 B	0644	2026-03-03 12:39:30	edit
sched.py	file	6,351 B	0644	2026-03-03 12:39:30	edit
secrets.py	file	1,984 B	0644	2026-03-03 12:39:30	edit
selectors.py	file	19,671 B	0644	2026-03-03 12:39:30	edit
shelve.py	file	8,560 B	0644	2026-03-03 12:39:30	edit
shlex.py	file	13,353 B	0644	2026-03-03 12:39:30	edit
shutil.py	file	56,762 B	0644	2026-03-03 12:39:30	edit
signal.py	file	2,495 B	0644	2026-03-03 12:39:30	edit
site.py	file	23,439 B	0644	2026-07-10 00:00:00	edit
smtplib.py	file	43,531 B	0755	2026-03-03 12:39:30	edit
sndhdr.py	file	7,448 B	0644	2026-03-03 12:39:30	edit
socket.py	file	37,815 B	0644	2026-03-03 12:39:30	edit
socketserver.py	file	28,065 B	0644	2026-03-03 12:39:30	edit
sre_compile.py	file	231 B	0644	2026-03-03 12:39:30	edit
sre_constants.py	file	232 B	0644	2026-03-03 12:39:30	edit
sre_parse.py	file	229 B	0644	2026-03-03 12:39:30	edit
ssl.py	file	50,904 B	0644	2026-03-03 12:39:30	edit
stat.py	file	5,485 B	0644	2026-03-03 12:39:30	edit
statistics.py	file	50,227 B	0644	2026-03-03 12:39:30	edit
string.py	file	11,786 B	0644	2026-03-03 12:39:30	edit
stringprep.py	file	12,917 B	0644	2026-03-03 12:39:30	edit
struct.py	file	257 B	0644	2026-03-03 12:39:30	edit
subprocess.py	file	88,747 B	0644	2026-03-03 12:39:30	edit
sunau.py	file	18,478 B	0644	2026-03-03 12:39:30	edit
symtable.py	file	12,477 B	0644	2026-03-03 12:39:30	edit
sysconfig.py	file	33,773 B	0644	2026-07-10 00:00:00	edit
tabnanny.py	file	11,531 B	0755	2026-03-03 12:39:30	edit
tarfile.py	file	114,250 B	0755	2026-07-10 00:00:00	edit
telnetlib.py	file	23,334 B	0644	2026-03-03 12:39:30	edit
tempfile.py	file	32,386 B	0644	2026-03-03 12:39:30	edit
textwrap.py	file	19,718 B	0644	2026-03-03 12:39:30	edit
this.py	file	1,003 B	0644	2026-03-03 12:39:30	edit
threading.py	file	59,742 B	0644	2026-07-10 00:00:00	edit
timeit.py	file	13,463 B	0755	2026-03-03 12:39:30	edit
token.py	file	2,511 B	0644	2026-03-03 12:39:30	edit
tokenize.py	file	21,570 B	0644	2026-03-03 12:39:30	edit
trace.py	file	29,352 B	0755	2026-03-03 12:39:30	edit
traceback.py	file	46,393 B	0644	2026-03-03 12:39:30	edit
tracemalloc.py	file	18,047 B	0644	2026-03-03 12:39:30	edit
tty.py	file	2,035 B	0644	2026-03-03 12:39:30	edit
types.py	file	10,993 B	0644	2026-03-03 12:39:30	edit
typing.py	file	118,836 B	0644	2026-03-03 12:39:30	edit
uu.py	file	7,341 B	0644	2026-07-10 00:00:00	edit
uuid.py	file	29,656 B	0644	2026-03-03 12:39:30	edit
warnings.py	file	21,909 B	0644	2026-03-03 12:39:30	edit
wave.py	file	22,769 B	0644	2026-03-03 12:39:30	edit
weakref.py	file	21,513 B	0644	2026-03-03 12:39:30	edit
webbrowser.py	file	24,169 B	0755	2026-07-10 00:00:00	edit
xdrlib.py	file	5,942 B	0644	2026-03-03 12:39:30	edit
zipapp.py	file	7,543 B	0644	2026-03-03 12:39:30	edit
zipimport.py	file	27,840 B	0644	2026-03-03 12:39:30	edit

editing: _collections_abc.py

# Copyright 2007 Google, Inc. All Rights Reserved.
# Licensed to PSF under a Contributor Agreement.

"""Abstract Base Classes (ABCs) for collections, according to PEP 3119.

Unit tests are in test_collections.
"""

############ Maintenance notes #########################################
#
# ABCs are different from other standard library modules in that they
# specify compliance tests.  In general, once an ABC has been published,
# new methods (either abstract or concrete) cannot be added.
#
# Though classes that inherit from an ABC would automatically receive a
# new mixin method, registered classes would become non-compliant and
# violate the contract promised by ``isinstance(someobj, SomeABC)``.
#
# Though irritating, the correct procedure for adding new abstract or
# mixin methods is to create a new ABC as a subclass of the previous
# ABC.  For example, union(), intersection(), and difference() cannot
# be added to Set but could go into a new ABC that extends Set.
#
# Because they are so hard to change, new ABCs should have their APIs
# carefully thought through prior to publication.
#
# Since ABCMeta only checks for the presence of methods, it is possible
# to alter the signature of a method by adding optional arguments
# or changing parameters names.  This is still a bit dubious but at
# least it won't cause isinstance() to return an incorrect result.
#
#
#######################################################################

from abc import ABCMeta, abstractmethod
import sys

GenericAlias = type(list[int])
EllipsisType = type(...)
def _f(): pass
FunctionType = type(_f)
del _f

__all__ = ["Awaitable", "Coroutine",
           "AsyncIterable", "AsyncIterator", "AsyncGenerator",
           "Hashable", "Iterable", "Iterator", "Generator", "Reversible",
           "Sized", "Container", "Callable", "Collection",
           "Set", "MutableSet",
           "Mapping", "MutableMapping",
           "MappingView", "KeysView", "ItemsView", "ValuesView",
           "Sequence", "MutableSequence",
           "ByteString", "Buffer",
           ]

# This module has been renamed from collections.abc to _collections_abc to
# speed up interpreter startup. Some of the types such as MutableMapping are
# required early but collections module imports a lot of other modules.
# See issue #19218
__name__ = "collections.abc"

# Private list of types that we want to register with the various ABCs
# so that they will pass tests like:
#       it = iter(somebytearray)
#       assert isinstance(it, Iterable)
# Note:  in other implementations, these types might not be distinct
# and they may have their own implementation specific types that
# are not included on this list.
bytes_iterator = type(iter(b''))
bytearray_iterator = type(iter(bytearray()))
#callable_iterator = ???
dict_keyiterator = type(iter({}.keys()))
dict_valueiterator = type(iter({}.values()))
dict_itemiterator = type(iter({}.items()))
list_iterator = type(iter([]))
list_reverseiterator = type(iter(reversed([])))
range_iterator = type(iter(range(0)))
longrange_iterator = type(iter(range(1 << 1000)))
set_iterator = type(iter(set()))
str_iterator = type(iter(""))
tuple_iterator = type(iter(()))
zip_iterator = type(iter(zip()))
## views ##
dict_keys = type({}.keys())
dict_values = type({}.values())
dict_items = type({}.items())
## misc ##
mappingproxy = type(type.__dict__)
generator = type((lambda: (yield))())
## coroutine ##
async def _coro(): pass
_coro = _coro()
coroutine = type(_coro)
_coro.close()  # Prevent ResourceWarning
del _coro
## asynchronous generator ##
async def _ag(): yield
_ag = _ag()
async_generator = type(_ag)
del _ag

### ONE-TRICK PONIES ###

def _check_methods(C, *methods):
    mro = C.__mro__
    for method in methods:
        for B in mro:
            if method in B.__dict__:
                if B.__dict__[method] is None:
                    return NotImplemented
                break
        else:
            return NotImplemented
    return True

class Hashable(metaclass=ABCMeta):

__slots__ = ()

@abstractmethod
    def __hash__(self):
        return 0

@classmethod
    def __subclasshook__(cls, C):
        if cls is Hashable:
            return _check_methods(C, "__hash__")
        return NotImplemented

class Awaitable(metaclass=ABCMeta):

__slots__ = ()

@abstractmethod
    def __await__(self):
        yield

@classmethod
    def __subclasshook__(cls, C):
        if cls is Awaitable:
            return _check_methods(C, "__await__")
        return NotImplemented

__class_getitem__ = classmethod(GenericAlias)

class Coroutine(Awaitable):

__slots__ = ()

@abstractmethod
    def send(self, value):
        """Send a value into the coroutine.
        Return next yielded value or raise StopIteration.
        """
        raise StopIteration

@abstractmethod
    def throw(self, typ, val=None, tb=None):
        """Raise an exception in the coroutine.
        Return next yielded value or raise StopIteration.
        """
        if val is None:
            if tb is None:
                raise typ
            val = typ()
        if tb is not None:
            val = val.with_traceback(tb)
        raise val

def close(self):
        """Raise GeneratorExit inside coroutine.
        """
        try:
            self.throw(GeneratorExit)
        except (GeneratorExit, StopIteration):
            pass
        else:
            raise RuntimeError("coroutine ignored GeneratorExit")

@classmethod
    def __subclasshook__(cls, C):
        if cls is Coroutine:
            return _check_methods(C, '__await__', 'send', 'throw', 'close')
        return NotImplemented

Coroutine.register(coroutine)

class AsyncIterable(metaclass=ABCMeta):

__slots__ = ()

@abstractmethod
    def __aiter__(self):
        return AsyncIterator()

@classmethod
    def __subclasshook__(cls, C):
        if cls is AsyncIterable:
            return _check_methods(C, "__aiter__")
        return NotImplemented

__class_getitem__ = classmethod(GenericAlias)

class AsyncIterator(AsyncIterable):

__slots__ = ()

@abstractmethod
    async def __anext__(self):
        """Return the next item or raise StopAsyncIteration when exhausted."""
        raise StopAsyncIteration

def __aiter__(self):
        return self

@classmethod
    def __subclasshook__(cls, C):
        if cls is AsyncIterator:
            return _check_methods(C, "__anext__", "__aiter__")
        return NotImplemented

class AsyncGenerator(AsyncIterator):

__slots__ = ()

async def __anext__(self):
        """Return the next item from the asynchronous generator.
        When exhausted, raise StopAsyncIteration.
        """
        return await self.asend(None)

@abstractmethod
    async def asend(self, value):
        """Send a value into the asynchronous generator.
        Return next yielded value or raise StopAsyncIteration.
        """
        raise StopAsyncIteration

@abstractmethod
    async def athrow(self, typ, val=None, tb=None):
        """Raise an exception in the asynchronous generator.
        Return next yielded value or raise StopAsyncIteration.
        """
        if val is None:
            if tb is None:
                raise typ
            val = typ()
        if tb is not None:
            val = val.with_traceback(tb)
        raise val

async def aclose(self):
        """Raise GeneratorExit inside coroutine.
        """
        try:
            await self.athrow(GeneratorExit)
        except (GeneratorExit, StopAsyncIteration):
            pass
        else:
            raise RuntimeError("asynchronous generator ignored GeneratorExit")

@classmethod
    def __subclasshook__(cls, C):
        if cls is AsyncGenerator:
            return _check_methods(C, '__aiter__', '__anext__',
                                  'asend', 'athrow', 'aclose')
        return NotImplemented

AsyncGenerator.register(async_generator)

class Iterable(metaclass=ABCMeta):

__slots__ = ()

@abstractmethod
    def __iter__(self):
        while False:
            yield None

@classmethod
    def __subclasshook__(cls, C):
        if cls is Iterable:
            return _check_methods(C, "__iter__")
        return NotImplemented

__class_getitem__ = classmethod(GenericAlias)

class Iterator(Iterable):

__slots__ = ()

@abstractmethod
    def __next__(self):
        'Return the next item from the iterator. When exhausted, raise StopIteration'
        raise StopIteration

def __iter__(self):
        return self

@classmethod
    def __subclasshook__(cls, C):
        if cls is Iterator:
            return _check_methods(C, '__iter__', '__next__')
        return NotImplemented

Iterator.register(bytes_iterator)
Iterator.register(bytearray_iterator)
#Iterator.register(callable_iterator)
Iterator.register(dict_keyiterator)
Iterator.register(dict_valueiterator)
Iterator.register(dict_itemiterator)
Iterator.register(list_iterator)
Iterator.register(list_reverseiterator)
Iterator.register(range_iterator)
Iterator.register(longrange_iterator)
Iterator.register(set_iterator)
Iterator.register(str_iterator)
Iterator.register(tuple_iterator)
Iterator.register(zip_iterator)

class Reversible(Iterable):

__slots__ = ()

@abstractmethod
    def __reversed__(self):
        while False:
            yield None

@classmethod
    def __subclasshook__(cls, C):
        if cls is Reversible:
            return _check_methods(C, "__reversed__", "__iter__")
        return NotImplemented

class Generator(Iterator):

__slots__ = ()

def __next__(self):
        """Return the next item from the generator.
        When exhausted, raise StopIteration.
        """
        return self.send(None)

@abstractmethod
    def send(self, value):
        """Send a value into the generator.
        Return next yielded value or raise StopIteration.
        """
        raise StopIteration

@abstractmethod
    def throw(self, typ, val=None, tb=None):
        """Raise an exception in the generator.
        Return next yielded value or raise StopIteration.
        """
        if val is None:
            if tb is None:
                raise typ
            val = typ()
        if tb is not None:
            val = val.with_traceback(tb)
        raise val

def close(self):
        """Raise GeneratorExit inside generator.
        """
        try:
            self.throw(GeneratorExit)
        except (GeneratorExit, StopIteration):
            pass
        else:
            raise RuntimeError("generator ignored GeneratorExit")

@classmethod
    def __subclasshook__(cls, C):
        if cls is Generator:
            return _check_methods(C, '__iter__', '__next__',
                                  'send', 'throw', 'close')
        return NotImplemented

Generator.register(generator)

class Sized(metaclass=ABCMeta):

__slots__ = ()

@abstractmethod
    def __len__(self):
        return 0

@classmethod
    def __subclasshook__(cls, C):
        if cls is Sized:
            return _check_methods(C, "__len__")
        return NotImplemented

class Container(metaclass=ABCMeta):

__slots__ = ()

@abstractmethod
    def __contains__(self, x):
        return False

@classmethod
    def __subclasshook__(cls, C):
        if cls is Container:
            return _check_methods(C, "__contains__")
        return NotImplemented

__class_getitem__ = classmethod(GenericAlias)

class Collection(Sized, Iterable, Container):

__slots__ = ()

@classmethod
    def __subclasshook__(cls, C):
        if cls is Collection:
            return _check_methods(C,  "__len__", "__iter__", "__contains__")
        return NotImplemented

class Buffer(metaclass=ABCMeta):

__slots__ = ()

@abstractmethod
    def __buffer__(self, flags: int, /) -> memoryview:
        raise NotImplementedError

@classmethod
    def __subclasshook__(cls, C):
        if cls is Buffer:
            return _check_methods(C, "__buffer__")
        return NotImplemented

class _CallableGenericAlias(GenericAlias):
    """ Represent `Callable[argtypes, resulttype]`.

This sets ``__args__`` to a tuple containing the flattened ``argtypes``
    followed by ``resulttype``.

Example: ``Callable[[int, str], float]`` sets ``__args__`` to
    ``(int, str, float)``.
    """

__slots__ = ()

def __new__(cls, origin, args):
        if not (isinstance(args, tuple) and len(args) == 2):
            raise TypeError(
                "Callable must be used as Callable[[arg, ...], result].")
        t_args, t_result = args
        if isinstance(t_args, (tuple, list)):
            args = (*t_args, t_result)
        elif not _is_param_expr(t_args):
            raise TypeError(f"Expected a list of types, an ellipsis, "
                            f"ParamSpec, or Concatenate. Got {t_args}")
        return super().__new__(cls, origin, args)

def __repr__(self):
        if len(self.__args__) == 2 and _is_param_expr(self.__args__[0]):
            return super().__repr__()
        return (f'collections.abc.Callable'
                f'[[{", ".join([_type_repr(a) for a in self.__args__[:-1]])}], '
                f'{_type_repr(self.__args__[-1])}]')

def __reduce__(self):
        args = self.__args__
        if not (len(args) == 2 and _is_param_expr(args[0])):
            args = list(args[:-1]), args[-1]
        return _CallableGenericAlias, (Callable, args)

def __getitem__(self, item):
        # Called during TypeVar substitution, returns the custom subclass
        # rather than the default types.GenericAlias object.  Most of the
        # code is copied from typing's _GenericAlias and the builtin
        # types.GenericAlias.
        if not isinstance(item, tuple):
            item = (item,)

new_args = super().__getitem__(item).__args__

# args[0] occurs due to things like Z[[int, str, bool]] from PEP 612
        if not isinstance(new_args[0], (tuple, list)):
            t_result = new_args[-1]
            t_args = new_args[:-1]
            new_args = (t_args, t_result)
        return _CallableGenericAlias(Callable, tuple(new_args))

def _is_param_expr(obj):
    """Checks if obj matches either a list of types, ``...``, ``ParamSpec`` or
    ``_ConcatenateGenericAlias`` from typing.py
    """
    if obj is Ellipsis:
        return True
    if isinstance(obj, list):
        return True
    obj = type(obj)
    names = ('ParamSpec', '_ConcatenateGenericAlias')
    return obj.__module__ == 'typing' and any(obj.__name__ == name for name in names)

def _type_repr(obj):
    """Return the repr() of an object, special-casing types (internal helper).

Copied from :mod:`typing` since collections.abc
    shouldn't depend on that module.
    (Keep this roughly in sync with the typing version.)
    """
    if isinstance(obj, type):
        if obj.__module__ == 'builtins':
            return obj.__qualname__
        return f'{obj.__module__}.{obj.__qualname__}'
    if obj is Ellipsis:
        return '...'
    if isinstance(obj, FunctionType):
        return obj.__name__
    return repr(obj)

class Callable(metaclass=ABCMeta):

__slots__ = ()

@abstractmethod
    def __call__(self, *args, **kwds):
        return False

@classmethod
    def __subclasshook__(cls, C):
        if cls is Callable:
            return _check_methods(C, "__call__")
        return NotImplemented

__class_getitem__ = classmethod(_CallableGenericAlias)

### SETS ###

class Set(Collection):
    """A set is a finite, iterable container.

This class provides concrete generic implementations of all
    methods except for __contains__, __iter__ and __len__.

To override the comparisons (presumably for speed, as the
    semantics are fixed), redefine __le__ and __ge__,
    then the other operations will automatically follow suit.
    """

__slots__ = ()

def __le__(self, other):
        if not isinstance(other, Set):
            return NotImplemented
        if len(self) > len(other):
            return False
        for elem in self:
            if elem not in other:
                return False
        return True

def __lt__(self, other):
        if not isinstance(other, Set):
            return NotImplemented
        return len(self) < len(other) and self.__le__(other)

def __gt__(self, other):
        if not isinstance(other, Set):
            return NotImplemented
        return len(self) > len(other) and self.__ge__(other)

def __ge__(self, other):
        if not isinstance(other, Set):
            return NotImplemented
        if len(self) < len(other):
            return False
        for elem in other:
            if elem not in self:
                return False
        return True

def __eq__(self, other):
        if not isinstance(other, Set):
            return NotImplemented
        return len(self) == len(other) and self.__le__(other)

@classmethod
    def _from_iterable(cls, it):
        '''Construct an instance of the class from any iterable input.

Must override this method if the class constructor signature
        does not accept an iterable for an input.
        '''
        return cls(it)

def __and__(self, other):
        if not isinstance(other, Iterable):
            return NotImplemented
        return self._from_iterable(value for value in other if value in self)

__rand__ = __and__

def isdisjoint(self, other):
        'Return True if two sets have a null intersection.'
        for value in other:
            if value in self:
                return False
        return True

def __or__(self, other):
        if not isinstance(other, Iterable):
            return NotImplemented
        chain = (e for s in (self, other) for e in s)
        return self._from_iterable(chain)

__ror__ = __or__

def __sub__(self, other):
        if not isinstance(other, Set):
            if not isinstance(other, Iterable):
                return NotImplemented
            other = self._from_iterable(other)
        return self._from_iterable(value for value in self
                                   if value not in other)

def __rsub__(self, other):
        if not isinstance(other, Set):
            if not isinstance(other, Iterable):
                return NotImplemented
            other = self._from_iterable(other)
        return self._from_iterable(value for value in other
                                   if value not in self)

def __xor__(self, other):
        if not isinstance(other, Set):
            if not isinstance(other, Iterable):
                return NotImplemented
            other = self._from_iterable(other)
        return (self - other) | (other - self)

__rxor__ = __xor__

def _hash(self):
        """Compute the hash value of a set.

Note that we don't define __hash__: not all sets are hashable.
        But if you define a hashable set type, its __hash__ should
        call this function.

This must be compatible __eq__.

All sets ought to compare equal if they contain the same
        elements, regardless of how they are implemented, and
        regardless of the order of the elements; so there's not much
        freedom for __eq__ or __hash__.  We match the algorithm used
        by the built-in frozenset type.
        """
        MAX = sys.maxsize
        MASK = 2 * MAX + 1
        n = len(self)
        h = 1927868237 * (n + 1)
        h &= MASK
        for x in self:
            hx = hash(x)
            h ^= (hx ^ (hx << 16) ^ 89869747)  * 3644798167
            h &= MASK
        h ^= (h >> 11) ^ (h >> 25)
        h = h * 69069 + 907133923
        h &= MASK
        if h > MAX:
            h -= MASK + 1
        if h == -1:
            h = 590923713
        return h

Set.register(frozenset)

class MutableSet(Set):
    """A mutable set is a finite, iterable container.

This class provides concrete generic implementations of all
    methods except for __contains__, __iter__, __len__,
    add(), and discard().

To override the comparisons (presumably for speed, as the
    semantics are fixed), all you have to do is redefine __le__ and
    then the other operations will automatically follow suit.
    """

__slots__ = ()

@abstractmethod
    def add(self, value):
        """Add an element."""
        raise NotImplementedError

@abstractmethod
    def discard(self, value):
        """Remove an element.  Do not raise an exception if absent."""
        raise NotImplementedError

def remove(self, value):
        """Remove an element. If not a member, raise a KeyError."""
        if value not in self:
            raise KeyError(value)
        self.discard(value)

def pop(self):
        """Return the popped value.  Raise KeyError if empty."""
        it = iter(self)
        try:
            value = next(it)
        except StopIteration:
            raise KeyError from None
        self.discard(value)
        return value

def clear(self):
        """This is slow (creates N new iterators!) but effective."""
        try:
            while True:
                self.pop()
        except KeyError:
            pass

def __ior__(self, it):
        for value in it:
            self.add(value)
        return self

def __iand__(self, it):
        for value in (self - it):
            self.discard(value)
        return self

def __ixor__(self, it):
        if it is self:
            self.clear()
        else:
            if not isinstance(it, Set):
                it = self._from_iterable(it)
            for value in it:
                if value in self:
                    self.discard(value)
                else:
                    self.add(value)
        return self

def __isub__(self, it):
        if it is self:
            self.clear()
        else:
            for value in it:
                self.discard(value)
        return self

MutableSet.register(set)

### MAPPINGS ###

class Mapping(Collection):
    """A Mapping is a generic container for associating key/value
    pairs.

This class provides concrete generic implementations of all
    methods except for __getitem__, __iter__, and __len__.
    """

__slots__ = ()

# Tell ABCMeta.__new__ that this class should have TPFLAGS_MAPPING set.
    __abc_tpflags__ = 1 << 6 # Py_TPFLAGS_MAPPING

@abstractmethod
    def __getitem__(self, key):
        raise KeyError

def get(self, key, default=None):
        'D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.'
        try:
            return self[key]
        except KeyError:
            return default

def __contains__(self, key):
        try:
            self[key]
        except KeyError:
            return False
        else:
            return True

def keys(self):
        "D.keys() -> a set-like object providing a view on D's keys"
        return KeysView(self)

def items(self):
        "D.items() -> a set-like object providing a view on D's items"
        return ItemsView(self)

def values(self):
        "D.values() -> an object providing a view on D's values"
        return ValuesView(self)

def __eq__(self, other):
        if not isinstance(other, Mapping):
            return NotImplemented
        return dict(self.items()) == dict(other.items())

__reversed__ = None

Mapping.register(mappingproxy)

class MappingView(Sized):

__slots__ = '_mapping',

def __init__(self, mapping):
        self._mapping = mapping

def __len__(self):
        return len(self._mapping)

def __repr__(self):
        return '{0.__class__.__name__}({0._mapping!r})'.format(self)

__class_getitem__ = classmethod(GenericAlias)

class KeysView(MappingView, Set):

__slots__ = ()

@classmethod
    def _from_iterable(cls, it):
        return set(it)

def __contains__(self, key):
        return key in self._mapping

def __iter__(self):
        yield from self._mapping

KeysView.register(dict_keys)

class ItemsView(MappingView, Set):

__slots__ = ()

@classmethod
    def _from_iterable(cls, it):
        return set(it)

def __contains__(self, item):
        key, value = item
        try:
            v = self._mapping[key]
        except KeyError:
            return False
        else:
            return v is value or v == value

def __iter__(self):
        for key in self._mapping:
            yield (key, self._mapping[key])

ItemsView.register(dict_items)

class ValuesView(MappingView, Collection):

__slots__ = ()

def __contains__(self, value):
        for key in self._mapping:
            v = self._mapping[key]
            if v is value or v == value:
                return True
        return False

def __iter__(self):
        for key in self._mapping:
            yield self._mapping[key]

ValuesView.register(dict_values)

class MutableMapping(Mapping):
    """A MutableMapping is a generic container for associating
    key/value pairs.

This class provides concrete generic implementations of all
    methods except for __getitem__, __setitem__, __delitem__,
    __iter__, and __len__.
    """

__slots__ = ()

@abstractmethod
    def __setitem__(self, key, value):
        raise KeyError

@abstractmethod
    def __delitem__(self, key):
        raise KeyError

__marker = object()

def pop(self, key, default=__marker):
        '''D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
          If key is not found, d is returned if given, otherwise KeyError is raised.
        '''
        try:
            value = self[key]
        except KeyError:
            if default is self.__marker:
                raise
            return default
        else:
            del self[key]
            return value

def popitem(self):
        '''D.popitem() -> (k, v), remove and return some (key, value) pair
           as a 2-tuple; but raise KeyError if D is empty.
        '''
        try:
            key = next(iter(self))
        except StopIteration:
            raise KeyError from None
        value = self[key]
        del self[key]
        return key, value

def clear(self):
        'D.clear() -> None.  Remove all items from D.'
        try:
            while True:
                self.popitem()
        except KeyError:
            pass

def update(self, other=(), /, **kwds):
        ''' D.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.keys(): 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
        '''
        if isinstance(other, Mapping):
            for key in other:
                self[key] = other[key]
        elif hasattr(other, "keys"):
            for key in other.keys():
                self[key] = other[key]
        else:
            for key, value in other:
                self[key] = value
        for key, value in kwds.items():
            self[key] = value

def setdefault(self, key, default=None):
        'D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D'
        try:
            return self[key]
        except KeyError:
            self[key] = default
        return default

MutableMapping.register(dict)

### SEQUENCES ###

class Sequence(Reversible, Collection):
    """All the operations on a read-only sequence.

Concrete subclasses must override __new__ or __init__,
    __getitem__, and __len__.
    """

__slots__ = ()

# Tell ABCMeta.__new__ that this class should have TPFLAGS_SEQUENCE set.
    __abc_tpflags__ = 1 << 5 # Py_TPFLAGS_SEQUENCE

@abstractmethod
    def __getitem__(self, index):
        raise IndexError

def __iter__(self):
        i = 0
        try:
            while True:
                v = self[i]
                yield v
                i += 1
        except IndexError:
            return

def __contains__(self, value):
        for v in self:
            if v is value or v == value:
                return True
        return False

def __reversed__(self):
        for i in reversed(range(len(self))):
            yield self[i]

def index(self, value, start=0, stop=None):
        '''S.index(value, [start, [stop]]) -> integer -- return first index of value.
           Raises ValueError if the value is not present.

Supporting start and stop arguments is optional, but
           recommended.
        '''
        if start is not None and start < 0:
            start = max(len(self) + start, 0)
        if stop is not None and stop < 0:
            stop += len(self)

i = start
        while stop is None or i < stop:
            try:
                v = self[i]
            except IndexError:
                break
            if v is value or v == value:
                return i
            i += 1
        raise ValueError

def count(self, value):
        'S.count(value) -> integer -- return number of occurrences of value'
        return sum(1 for v in self if v is value or v == value)

Sequence.register(tuple)
Sequence.register(str)
Sequence.register(range)
Sequence.register(memoryview)

class _DeprecateByteStringMeta(ABCMeta):
    def __new__(cls, name, bases, namespace, **kwargs):
        if name != "ByteString":
            import warnings

warnings._deprecated(
                "collections.abc.ByteString",
                remove=(3, 14),
            )
        return super().__new__(cls, name, bases, namespace, **kwargs)

def __instancecheck__(cls, instance):
        import warnings

warnings._deprecated(
            "collections.abc.ByteString",
            remove=(3, 14),
        )
        return super().__instancecheck__(instance)

class ByteString(Sequence, metaclass=_DeprecateByteStringMeta):
    """This unifies bytes and bytearray.

XXX Should add all their methods.
    """

__slots__ = ()

ByteString.register(bytes)
ByteString.register(bytearray)

class MutableSequence(Sequence):
    """All the operations on a read-write sequence.

Concrete subclasses must provide __new__ or __init__,
    __getitem__, __setitem__, __delitem__, __len__, and insert().
    """

__slots__ = ()

@abstractmethod
    def __setitem__(self, index, value):
        raise IndexError

@abstractmethod
    def __delitem__(self, index):
        raise IndexError

@abstractmethod
    def insert(self, index, value):
        'S.insert(index, value) -- insert value before index'
        raise IndexError

def append(self, value):
        'S.append(value) -- append value to the end of the sequence'
        self.insert(len(self), value)

def clear(self):
        'S.clear() -> None -- remove all items from S'
        try:
            while True:
                self.pop()
        except IndexError:
            pass

def reverse(self):
        'S.reverse() -- reverse *IN PLACE*'
        n = len(self)
        for i in range(n//2):
            self[i], self[n-i-1] = self[n-i-1], self[i]

def extend(self, values):
        'S.extend(iterable) -- extend sequence by appending elements from the iterable'
        if values is self:
            values = list(values)
        for v in values:
            self.append(v)

def pop(self, index=-1):
        '''S.pop([index]) -> item -- remove and return item at index (default last).
           Raise IndexError if list is empty or index is out of range.
        '''
        v = self[index]
        del self[index]
        return v

def remove(self, value):
        '''S.remove(value) -- remove first occurrence of value.
           Raise ValueError if the value is not present.
        '''
        del self[self.index(value)]

def __iadd__(self, values):
        self.extend(values)
        return self

MutableSequence.register(list)
MutableSequence.register(bytearray)  # Multiply inheriting, see ByteString

cancel