bpo-30144: Import collections ABC from collections.abc rather than collections. (#1263)

This commit is contained in:
Serhiy Storchaka 2017-04-24 09:05:00 +03:00 committed by GitHub
parent 9eb5ca0774
commit 2e576f5aec
22 changed files with 90 additions and 85 deletions

View File

@ -372,7 +372,7 @@ also send your request step by step, by using the four functions below.
Section 3.3.1. How the data is encoded is dependent on the type of Section 3.3.1. How the data is encoded is dependent on the type of
*message_body*. If *message_body* implements the :ref:`buffer interface *message_body*. If *message_body* implements the :ref:`buffer interface
<bufferobjects>` the encoding will result in a single chunk. <bufferobjects>` the encoding will result in a single chunk.
If *message_body* is a :class:`collections.Iterable`, each iteration If *message_body* is a :class:`collections.abc.Iterable`, each iteration
of *message_body* will result in a chunk. If *message_body* is a of *message_body* will result in a chunk. If *message_body* is a
:term:`file object`, each call to ``.read()`` will result in a chunk. :term:`file object`, each call to ``.read()`` will result in a chunk.
The method automatically signals the end of the chunk-encoded data The method automatically signals the end of the chunk-encoded data

View File

@ -1375,7 +1375,7 @@ Basic customization
:meth:`__hash__` method of a class is ``None``, instances of the class will :meth:`__hash__` method of a class is ``None``, instances of the class will
raise an appropriate :exc:`TypeError` when a program attempts to retrieve raise an appropriate :exc:`TypeError` when a program attempts to retrieve
their hash value, and will also be correctly identified as unhashable when their hash value, and will also be correctly identified as unhashable when
checking ``isinstance(obj, collections.Hashable)``. checking ``isinstance(obj, collections.abc.Hashable)``.
If a class that overrides :meth:`__eq__` needs to retain the implementation If a class that overrides :meth:`__eq__` needs to retain the implementation
of :meth:`__hash__` from a parent class, the interpreter must be told this of :meth:`__hash__` from a parent class, the interpreter must be told this
@ -1385,7 +1385,7 @@ Basic customization
support, it should include ``__hash__ = None`` in the class definition. support, it should include ``__hash__ = None`` in the class definition.
A class which defines its own :meth:`__hash__` that explicitly raises A class which defines its own :meth:`__hash__` that explicitly raises
a :exc:`TypeError` would be incorrectly identified as hashable by a :exc:`TypeError` would be incorrectly identified as hashable by
an ``isinstance(obj, collections.Hashable)`` call. an ``isinstance(obj, collections.abc.Hashable)`` call.
.. note:: .. note::
@ -1981,7 +1981,7 @@ range of items. It is also recommended that mappings provide the methods
:meth:`keys`, :meth:`values`, :meth:`items`, :meth:`get`, :meth:`clear`, :meth:`keys`, :meth:`values`, :meth:`items`, :meth:`get`, :meth:`clear`,
:meth:`setdefault`, :meth:`pop`, :meth:`popitem`, :meth:`!copy`, and :meth:`setdefault`, :meth:`pop`, :meth:`popitem`, :meth:`!copy`, and
:meth:`update` behaving similar to those for Python's standard dictionary :meth:`update` behaving similar to those for Python's standard dictionary
objects. The :mod:`collections` module provides a objects. The :mod:`collections.abc` module provides a
:class:`~collections.abc.MutableMapping` :class:`~collections.abc.MutableMapping`
abstract base class to help create those methods from a base set of abstract base class to help create those methods from a base set of
:meth:`__getitem__`, :meth:`__setitem__`, :meth:`__delitem__`, and :meth:`keys`. :meth:`__getitem__`, :meth:`__setitem__`, :meth:`__delitem__`, and :meth:`keys`.

View File

@ -14,6 +14,7 @@
""" """
import collections import collections
import collections.abc
import concurrent.futures import concurrent.futures
import heapq import heapq
import itertools import itertools
@ -1001,7 +1002,7 @@ def create_server(self, protocol_factory, host=None, port=None,
if host == '': if host == '':
hosts = [None] hosts = [None]
elif (isinstance(host, str) or elif (isinstance(host, str) or
not isinstance(host, collections.Iterable)): not isinstance(host, collections.abc.Iterable)):
hosts = [host] hosts = [host]
else: else:
hosts = host hosts = host

View File

@ -32,7 +32,7 @@
# ======= # =======
from io import StringIO, BytesIO, TextIOWrapper from io import StringIO, BytesIO, TextIOWrapper
from collections import Mapping from collections.abc import Mapping
import sys import sys
import os import os
import urllib.parse import urllib.parse

View File

@ -24,7 +24,7 @@
import ast as _ast import ast as _ast
import io as _io import io as _io
import os as _os import os as _os
import collections import collections.abc
__all__ = ["error", "open"] __all__ = ["error", "open"]
@ -32,7 +32,7 @@
error = OSError error = OSError
class _Database(collections.MutableMapping): class _Database(collections.abc.MutableMapping):
# The on-disk directory and data files can remain in mutually # The on-disk directory and data files can remain in mutually
# inconsistent states for an arbitrarily long time (see comments # inconsistent states for an arbitrarily long time (see comments

View File

@ -74,7 +74,7 @@
import io import io
import re import re
import socket import socket
import collections import collections.abc
from urllib.parse import urlsplit from urllib.parse import urlsplit
# HTTPMessage, parse_headers(), and the HTTP status code constants are # HTTPMessage, parse_headers(), and the HTTP status code constants are
@ -977,7 +977,7 @@ def send(self, data):
try: try:
self.sock.sendall(data) self.sock.sendall(data)
except TypeError: except TypeError:
if isinstance(data, collections.Iterable): if isinstance(data, collections.abc.Iterable):
for d in data: for d in data:
self.sock.sendall(d) self.sock.sendall(d)
else: else:

View File

@ -1,4 +1,4 @@
from collections import Mapping from collections.abc import Mapping
import re import re
import sys import sys

View File

@ -9,7 +9,7 @@
operator.irepeat(obj, n) -> operator.imul(obj, n) operator.irepeat(obj, n) -> operator.imul(obj, n)
""" """
import collections import collections.abc
# Local imports # Local imports
from lib2to3 import fixer_base from lib2to3 import fixer_base
@ -88,7 +88,7 @@ def _handle_type2abc(self, node, results, module, abc):
def _check_method(self, node, results): def _check_method(self, node, results):
method = getattr(self, "_" + results["method"][0].value) method = getattr(self, "_" + results["method"][0].value)
if isinstance(method, collections.Callable): if isinstance(method, collections.abc.Callable):
if "module" in results: if "module" in results:
return method return method
else: else:

View File

@ -14,7 +14,7 @@
import encodings import encodings
import encodings.aliases import encodings.aliases
import re import re
import collections import collections.abc
from builtins import str as _builtin_str from builtins import str as _builtin_str
import functools import functools
import warnings import warnings
@ -215,7 +215,7 @@ def format_string(f, val, grouping=False, monetary=False):
percents = list(_percent_re.finditer(f)) percents = list(_percent_re.finditer(f))
new_f = _percent_re.sub('%s', f) new_f = _percent_re.sub('%s', f)
if isinstance(val, collections.Mapping): if isinstance(val, collections.abc.Mapping):
new_val = [] new_val = []
for perc in percents: for perc in percents:
if perc.group()[-1]=='%': if perc.group()[-1]=='%':

View File

@ -23,7 +23,7 @@
To use, simply 'import logging' and log away! To use, simply 'import logging' and log away!
""" """
import sys, os, time, io, traceback, warnings, weakref, collections import sys, os, time, io, traceback, warnings, weakref, collections.abc
from string import Template from string import Template
@ -273,8 +273,8 @@ def __init__(self, name, level, pathname, lineno,
# to hasattr(args[0], '__getitem__'). However, the docs on string # to hasattr(args[0], '__getitem__'). However, the docs on string
# formatting still seem to suggest a mapping object is required. # formatting still seem to suggest a mapping object is required.
# Thus, while not removing the isinstance check, it does now look # Thus, while not removing the isinstance check, it does now look
# for collections.Mapping rather than, as before, dict. # for collections.abc.Mapping rather than, as before, dict.
if (args and len(args) == 1 and isinstance(args[0], collections.Mapping) if (args and len(args) == 1 and isinstance(args[0], collections.abc.Mapping)
and args[0]): and args[0]):
args = args[0] args = args[0]
self.args = args self.args = args

View File

@ -6,7 +6,7 @@
import posixpath import posixpath
import re import re
import sys import sys
from collections import Sequence from collections.abc import Sequence
from errno import EINVAL, ENOENT, ENOTDIR from errno import EINVAL, ENOENT, ENOTDIR
from operator import attrgetter from operator import attrgetter
from stat import S_ISDIR, S_ISLNK, S_ISREG, S_ISSOCK, S_ISBLK, S_ISCHR, S_ISFIFO from stat import S_ISDIR, S_ISLNK, S_ISREG, S_ISSOCK, S_ISBLK, S_ISCHR, S_ISFIFO

View File

@ -6,7 +6,8 @@
from abc import ABCMeta, abstractmethod from abc import ABCMeta, abstractmethod
from collections import namedtuple, Mapping from collections import namedtuple
from collections.abc import Mapping
import math import math
import select import select
import sys import sys

View File

@ -59,11 +59,11 @@
from pickle import Pickler, Unpickler from pickle import Pickler, Unpickler
from io import BytesIO from io import BytesIO
import collections import collections.abc
__all__ = ["Shelf", "BsdDbShelf", "DbfilenameShelf", "open"] __all__ = ["Shelf", "BsdDbShelf", "DbfilenameShelf", "open"]
class _ClosedDict(collections.MutableMapping): class _ClosedDict(collections.abc.MutableMapping):
'Marker for a closed dict. Access attempts raise a ValueError.' 'Marker for a closed dict. Access attempts raise a ValueError.'
def closed(self, *args): def closed(self, *args):
@ -74,7 +74,7 @@ def __repr__(self):
return '<Closed Dictionary>' return '<Closed Dictionary>'
class Shelf(collections.MutableMapping): class Shelf(collections.abc.MutableMapping):
"""Base class for shelf implementations. """Base class for shelf implementations.
This is initialized with a dictionary-like object. This is initialized with a dictionary-like object.

View File

@ -1,4 +1,4 @@
import collections import collections.abc
import copy import copy
import pickle import pickle
import unittest import unittest
@ -249,23 +249,23 @@ def test_pickle(self):
def test_abc_registry(self): def test_abc_registry(self):
d = dict(a=1) d = dict(a=1)
self.assertIsInstance(d.keys(), collections.KeysView) self.assertIsInstance(d.keys(), collections.abc.KeysView)
self.assertIsInstance(d.keys(), collections.MappingView) self.assertIsInstance(d.keys(), collections.abc.MappingView)
self.assertIsInstance(d.keys(), collections.Set) self.assertIsInstance(d.keys(), collections.abc.Set)
self.assertIsInstance(d.keys(), collections.Sized) self.assertIsInstance(d.keys(), collections.abc.Sized)
self.assertIsInstance(d.keys(), collections.Iterable) self.assertIsInstance(d.keys(), collections.abc.Iterable)
self.assertIsInstance(d.keys(), collections.Container) self.assertIsInstance(d.keys(), collections.abc.Container)
self.assertIsInstance(d.values(), collections.ValuesView) self.assertIsInstance(d.values(), collections.abc.ValuesView)
self.assertIsInstance(d.values(), collections.MappingView) self.assertIsInstance(d.values(), collections.abc.MappingView)
self.assertIsInstance(d.values(), collections.Sized) self.assertIsInstance(d.values(), collections.abc.Sized)
self.assertIsInstance(d.items(), collections.ItemsView) self.assertIsInstance(d.items(), collections.abc.ItemsView)
self.assertIsInstance(d.items(), collections.MappingView) self.assertIsInstance(d.items(), collections.abc.MappingView)
self.assertIsInstance(d.items(), collections.Set) self.assertIsInstance(d.items(), collections.abc.Set)
self.assertIsInstance(d.items(), collections.Sized) self.assertIsInstance(d.items(), collections.abc.Sized)
self.assertIsInstance(d.items(), collections.Iterable) self.assertIsInstance(d.items(), collections.abc.Iterable)
self.assertIsInstance(d.items(), collections.Container) self.assertIsInstance(d.items(), collections.abc.Container)
if __name__ == "__main__": if __name__ == "__main__":

View File

@ -1,6 +1,7 @@
import abc import abc
import builtins import builtins
import collections import collections
import collections.abc
import copy import copy
from itertools import permutations from itertools import permutations
import pickle import pickle
@ -910,7 +911,7 @@ def mycmp(x, y):
key = self.cmp_to_key(mycmp) key = self.cmp_to_key(mycmp)
k = key(10) k = key(10)
self.assertRaises(TypeError, hash, k) self.assertRaises(TypeError, hash, k)
self.assertNotIsInstance(k, collections.Hashable) self.assertNotIsInstance(k, collections.abc.Hashable)
@unittest.skipUnless(c_functools, 'requires the C _functools module') @unittest.skipUnless(c_functools, 'requires the C _functools module')
@ -1707,7 +1708,7 @@ def _(obj):
def test_compose_mro(self): def test_compose_mro(self):
# None of the examples in this test depend on haystack ordering. # None of the examples in this test depend on haystack ordering.
c = collections c = collections.abc
mro = functools._compose_mro mro = functools._compose_mro
bases = [c.Sequence, c.MutableMapping, c.Mapping, c.Set] bases = [c.Sequence, c.MutableMapping, c.Mapping, c.Set]
for haystack in permutations(bases): for haystack in permutations(bases):
@ -1715,10 +1716,10 @@ def test_compose_mro(self):
self.assertEqual(m, [dict, c.MutableMapping, c.Mapping, self.assertEqual(m, [dict, c.MutableMapping, c.Mapping,
c.Collection, c.Sized, c.Iterable, c.Collection, c.Sized, c.Iterable,
c.Container, object]) c.Container, object])
bases = [c.Container, c.Mapping, c.MutableMapping, c.OrderedDict] bases = [c.Container, c.Mapping, c.MutableMapping, collections.OrderedDict]
for haystack in permutations(bases): for haystack in permutations(bases):
m = mro(c.ChainMap, haystack) m = mro(collections.ChainMap, haystack)
self.assertEqual(m, [c.ChainMap, c.MutableMapping, c.Mapping, self.assertEqual(m, [collections.ChainMap, c.MutableMapping, c.Mapping,
c.Collection, c.Sized, c.Iterable, c.Collection, c.Sized, c.Iterable,
c.Container, object]) c.Container, object])
@ -1728,39 +1729,39 @@ def test_compose_mro(self):
# test_mro_conflicts). # test_mro_conflicts).
bases = [c.Container, c.Sized, str] bases = [c.Container, c.Sized, str]
for haystack in permutations(bases): for haystack in permutations(bases):
m = mro(c.defaultdict, [c.Sized, c.Container, str]) m = mro(collections.defaultdict, [c.Sized, c.Container, str])
self.assertEqual(m, [c.defaultdict, dict, c.Sized, c.Container, self.assertEqual(m, [collections.defaultdict, dict, c.Sized,
object]) c.Container, object])
# MutableSequence below is registered directly on D. In other words, it # MutableSequence below is registered directly on D. In other words, it
# precedes MutableMapping which means single dispatch will always # precedes MutableMapping which means single dispatch will always
# choose MutableSequence here. # choose MutableSequence here.
class D(c.defaultdict): class D(collections.defaultdict):
pass pass
c.MutableSequence.register(D) c.MutableSequence.register(D)
bases = [c.MutableSequence, c.MutableMapping] bases = [c.MutableSequence, c.MutableMapping]
for haystack in permutations(bases): for haystack in permutations(bases):
m = mro(D, bases) m = mro(D, bases)
self.assertEqual(m, [D, c.MutableSequence, c.Sequence, c.Reversible, self.assertEqual(m, [D, c.MutableSequence, c.Sequence, c.Reversible,
c.defaultdict, dict, c.MutableMapping, c.Mapping, collections.defaultdict, dict, c.MutableMapping, c.Mapping,
c.Collection, c.Sized, c.Iterable, c.Container, c.Collection, c.Sized, c.Iterable, c.Container,
object]) object])
# Container and Callable are registered on different base classes and # Container and Callable are registered on different base classes and
# a generic function supporting both should always pick the Callable # a generic function supporting both should always pick the Callable
# implementation if a C instance is passed. # implementation if a C instance is passed.
class C(c.defaultdict): class C(collections.defaultdict):
def __call__(self): def __call__(self):
pass pass
bases = [c.Sized, c.Callable, c.Container, c.Mapping] bases = [c.Sized, c.Callable, c.Container, c.Mapping]
for haystack in permutations(bases): for haystack in permutations(bases):
m = mro(C, haystack) m = mro(C, haystack)
self.assertEqual(m, [C, c.Callable, c.defaultdict, dict, c.Mapping, self.assertEqual(m, [C, c.Callable, collections.defaultdict, dict, c.Mapping,
c.Collection, c.Sized, c.Iterable, c.Collection, c.Sized, c.Iterable,
c.Container, object]) c.Container, object])
def test_register_abc(self): def test_register_abc(self):
c = collections c = collections.abc
d = {"a": "b"} d = {"a": "b"}
l = [1, 2, 3] l = [1, 2, 3]
s = {object(), None} s = {object(), None}
@ -1786,7 +1787,7 @@ def g(obj):
self.assertEqual(g(s), "sized") self.assertEqual(g(s), "sized")
self.assertEqual(g(f), "sized") self.assertEqual(g(f), "sized")
self.assertEqual(g(t), "sized") self.assertEqual(g(t), "sized")
g.register(c.ChainMap, lambda obj: "chainmap") g.register(collections.ChainMap, lambda obj: "chainmap")
self.assertEqual(g(d), "mutablemapping") # irrelevant ABCs registered self.assertEqual(g(d), "mutablemapping") # irrelevant ABCs registered
self.assertEqual(g(l), "sized") self.assertEqual(g(l), "sized")
self.assertEqual(g(s), "sized") self.assertEqual(g(s), "sized")
@ -1854,7 +1855,7 @@ def g(obj):
self.assertEqual(g(t), "tuple") self.assertEqual(g(t), "tuple")
def test_c3_abc(self): def test_c3_abc(self):
c = collections c = collections.abc
mro = functools._c3_mro mro = functools._c3_mro
class A(object): class A(object):
pass pass
@ -1895,7 +1896,7 @@ def _(a):
self.assertEqual(fun(aa), 'fun A') self.assertEqual(fun(aa), 'fun A')
def test_mro_conflicts(self): def test_mro_conflicts(self):
c = collections c = collections.abc
@functools.singledispatch @functools.singledispatch
def g(arg): def g(arg):
return "base" return "base"
@ -1956,7 +1957,7 @@ def _(arg):
# MutableMapping's bases implicit as well from defaultdict's # MutableMapping's bases implicit as well from defaultdict's
# perspective. # perspective.
with self.assertRaises(RuntimeError) as re_two: with self.assertRaises(RuntimeError) as re_two:
h(c.defaultdict(lambda: 0)) h(collections.defaultdict(lambda: 0))
self.assertIn( self.assertIn(
str(re_two.exception), str(re_two.exception),
(("Ambiguous dispatch: <class 'collections.abc.Container'> " (("Ambiguous dispatch: <class 'collections.abc.Container'> "
@ -1964,7 +1965,7 @@ def _(arg):
("Ambiguous dispatch: <class 'collections.abc.Sized'> " ("Ambiguous dispatch: <class 'collections.abc.Sized'> "
"or <class 'collections.abc.Container'>")), "or <class 'collections.abc.Container'>")),
) )
class R(c.defaultdict): class R(collections.defaultdict):
pass pass
c.MutableSequence.register(R) c.MutableSequence.register(R)
@functools.singledispatch @functools.singledispatch
@ -2041,7 +2042,7 @@ def clear(self):
_orig_wkd = functools.WeakKeyDictionary _orig_wkd = functools.WeakKeyDictionary
td = TracingDict() td = TracingDict()
functools.WeakKeyDictionary = lambda: td functools.WeakKeyDictionary = lambda: td
c = collections c = collections.abc
@functools.singledispatch @functools.singledispatch
def g(arg): def g(arg):
return "base" return "base"

View File

@ -8,7 +8,7 @@
import sys import sys
import unittest import unittest
from test.support.script_helper import assert_python_ok from test.support.script_helper import assert_python_ok
from collections import Hashable from collections.abc import Hashable
IS_64BIT = sys.maxsize > 2**32 IS_64BIT = sys.maxsize > 2**32

View File

@ -1,4 +1,4 @@
import collections import collections.abc
import io import io
import os import os
import errno import errno
@ -1408,7 +1408,7 @@ def _check(glob, expected):
P = self.cls P = self.cls
p = P(BASE) p = P(BASE)
it = p.glob("fileA") it = p.glob("fileA")
self.assertIsInstance(it, collections.Iterator) self.assertIsInstance(it, collections.abc.Iterator)
_check(it, ["fileA"]) _check(it, ["fileA"])
_check(p.glob("fileB"), []) _check(p.glob("fileB"), [])
_check(p.glob("dir*/file*"), ["dirB/fileB", "dirC/fileC"]) _check(p.glob("dir*/file*"), ["dirB/fileB", "dirC/fileC"])
@ -1432,7 +1432,7 @@ def _check(glob, expected):
P = self.cls P = self.cls
p = P(BASE) p = P(BASE)
it = p.rglob("fileA") it = p.rglob("fileA")
self.assertIsInstance(it, collections.Iterator) self.assertIsInstance(it, collections.abc.Iterator)
_check(it, ["fileA"]) _check(it, ["fileA"])
_check(p.rglob("fileB"), ["dirB/fileB"]) _check(p.rglob("fileB"), ["dirB/fileB"])
_check(p.rglob("*/fileA"), []) _check(p.rglob("*/fileA"), [])

View File

@ -4,6 +4,7 @@
""" """
import collections import collections
import collections.abc
import decimal import decimal
import doctest import doctest
import math import math
@ -218,8 +219,8 @@ def assertApproxEqual(
if rel is None: if rel is None:
rel = self.rel rel = self.rel
if ( if (
isinstance(first, collections.Sequence) and isinstance(first, collections.abc.Sequence) and
isinstance(second, collections.Sequence) isinstance(second, collections.abc.Sequence)
): ):
check = self._check_approx_seq check = self._check_approx_seq
else: else:

View File

@ -2023,11 +2023,11 @@ def __len__(self):
self.assertIsSubclass(MMC, typing.Mapping) self.assertIsSubclass(MMC, typing.Mapping)
self.assertIsInstance(MMB[KT, VT](), typing.Mapping) self.assertIsInstance(MMB[KT, VT](), typing.Mapping)
self.assertIsInstance(MMB[KT, VT](), collections.Mapping) self.assertIsInstance(MMB[KT, VT](), collections_abc.Mapping)
self.assertIsSubclass(MMA, collections.Mapping) self.assertIsSubclass(MMA, collections_abc.Mapping)
self.assertIsSubclass(MMB, collections.Mapping) self.assertIsSubclass(MMB, collections_abc.Mapping)
self.assertIsSubclass(MMC, collections.Mapping) self.assertIsSubclass(MMC, collections_abc.Mapping)
self.assertIsSubclass(MMB[str, str], typing.Mapping) self.assertIsSubclass(MMB[str, str], typing.Mapping)
self.assertIsSubclass(MMC, MMA) self.assertIsSubclass(MMC, MMA)
@ -2039,9 +2039,9 @@ class G(typing.Generator[int, int, int]): ...
def g(): yield 0 def g(): yield 0
self.assertIsSubclass(G, typing.Generator) self.assertIsSubclass(G, typing.Generator)
self.assertIsSubclass(G, typing.Iterable) self.assertIsSubclass(G, typing.Iterable)
if hasattr(collections, 'Generator'): if hasattr(collections_abc, 'Generator'):
self.assertIsSubclass(G, collections.Generator) self.assertIsSubclass(G, collections_abc.Generator)
self.assertIsSubclass(G, collections.Iterable) self.assertIsSubclass(G, collections_abc.Iterable)
self.assertNotIsSubclass(type(g), G) self.assertNotIsSubclass(type(g), G)
@skipUnless(PY36, 'Python 3.6 required') @skipUnless(PY36, 'Python 3.6 required')
@ -2057,15 +2057,15 @@ def athrow(self, typ, val=None, tb=None):
g = ns['g'] g = ns['g']
self.assertIsSubclass(G, typing.AsyncGenerator) self.assertIsSubclass(G, typing.AsyncGenerator)
self.assertIsSubclass(G, typing.AsyncIterable) self.assertIsSubclass(G, typing.AsyncIterable)
self.assertIsSubclass(G, collections.AsyncGenerator) self.assertIsSubclass(G, collections_abc.AsyncGenerator)
self.assertIsSubclass(G, collections.AsyncIterable) self.assertIsSubclass(G, collections_abc.AsyncIterable)
self.assertNotIsSubclass(type(g), G) self.assertNotIsSubclass(type(g), G)
instance = G() instance = G()
self.assertIsInstance(instance, typing.AsyncGenerator) self.assertIsInstance(instance, typing.AsyncGenerator)
self.assertIsInstance(instance, typing.AsyncIterable) self.assertIsInstance(instance, typing.AsyncIterable)
self.assertIsInstance(instance, collections.AsyncGenerator) self.assertIsInstance(instance, collections_abc.AsyncGenerator)
self.assertIsInstance(instance, collections.AsyncIterable) self.assertIsInstance(instance, collections_abc.AsyncIterable)
self.assertNotIsInstance(type(g), G) self.assertNotIsInstance(type(g), G)
self.assertNotIsInstance(g, G) self.assertNotIsInstance(g, G)
@ -2102,23 +2102,23 @@ class D: ...
self.assertIsSubclass(D, B) self.assertIsSubclass(D, B)
class M(): ... class M(): ...
collections.MutableMapping.register(M) collections_abc.MutableMapping.register(M)
self.assertIsSubclass(M, typing.Mapping) self.assertIsSubclass(M, typing.Mapping)
def test_collections_as_base(self): def test_collections_as_base(self):
class M(collections.Mapping): ... class M(collections_abc.Mapping): ...
self.assertIsSubclass(M, typing.Mapping) self.assertIsSubclass(M, typing.Mapping)
self.assertIsSubclass(M, typing.Iterable) self.assertIsSubclass(M, typing.Iterable)
class S(collections.MutableSequence): ... class S(collections_abc.MutableSequence): ...
self.assertIsSubclass(S, typing.MutableSequence) self.assertIsSubclass(S, typing.MutableSequence)
self.assertIsSubclass(S, typing.Iterable) self.assertIsSubclass(S, typing.Iterable)
class I(collections.Iterable): ... class I(collections_abc.Iterable): ...
self.assertIsSubclass(I, typing.Iterable) self.assertIsSubclass(I, typing.Iterable)
class A(collections.Mapping, metaclass=abc.ABCMeta): ... class A(collections_abc.Mapping, metaclass=abc.ABCMeta): ...
class B: ... class B: ...
A.register(B) A.register(B)
self.assertIsSubclass(B, typing.Mapping) self.assertIsSubclass(B, typing.Mapping)

View File

@ -1,4 +1,4 @@
from collections import Sequence, Iterable from collections.abc import Sequence, Iterable
from functools import total_ordering from functools import total_ordering
import fnmatch import fnmatch
import linecache import linecache

View File

@ -21,7 +21,7 @@
from _weakrefset import WeakSet, _IterationGuard from _weakrefset import WeakSet, _IterationGuard
import collections # Import after _weakref to avoid circular import. import collections.abc # Import after _weakref to avoid circular import.
import sys import sys
import itertools import itertools
@ -87,7 +87,7 @@ def __ne__(self, other):
__hash__ = ref.__hash__ __hash__ = ref.__hash__
class WeakValueDictionary(collections.MutableMapping): class WeakValueDictionary(collections.abc.MutableMapping):
"""Mapping class that references values weakly. """Mapping class that references values weakly.
Entries in the dictionary will be discarded when no strong Entries in the dictionary will be discarded when no strong
@ -340,7 +340,7 @@ def __init__(self, ob, callback, key):
super().__init__(ob, callback) super().__init__(ob, callback)
class WeakKeyDictionary(collections.MutableMapping): class WeakKeyDictionary(collections.abc.MutableMapping):
""" Mapping class that references keys weakly. """ Mapping class that references keys weakly.
Entries in the dictionary will be discarded when there is no Entries in the dictionary will be discarded when there is no

View File

@ -96,6 +96,7 @@
import warnings import warnings
import io import io
import collections import collections
import collections.abc
import contextlib import contextlib
from . import ElementPath from . import ElementPath
@ -1231,7 +1232,7 @@ def iterator():
if close_source: if close_source:
source.close() source.close()
class IterParseIterator(collections.Iterator): class IterParseIterator(collections.abc.Iterator):
__next__ = iterator().__next__ __next__ = iterator().__next__
it = IterParseIterator() it = IterParseIterator()
it.root = None it.root = None