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
<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
:term:`file object`, each call to ``.read()`` will result in a chunk.
The method automatically signals the end of the chunk-encoded data
:meth:`__hash__` method of a class is ``None``, instances of the class will
raise an appropriate :exc:`TypeError` when a program attempts to retrieve
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
of :meth:`__hash__` from a parent class, the interpreter must be told this
support, it should include ``__hash__ = None`` in the class definition.
A class which defines its own :meth:`__hash__` that explicitly raises
a :exc:`TypeError` would be incorrectly identified as hashable by
- an ``isinstance(obj, collections.Hashable)`` call.
+ an ``isinstance(obj, collections.abc.Hashable)`` call.
.. note::
:meth:`keys`, :meth:`values`, :meth:`items`, :meth:`get`, :meth:`clear`,
:meth:`setdefault`, :meth:`pop`, :meth:`popitem`, :meth:`!copy`, and
: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`
abstract base class to help create those methods from a base set of
:meth:`__getitem__`, :meth:`__setitem__`, :meth:`__delitem__`, and :meth:`keys`.
"""
import collections
+import collections.abc
import concurrent.futures
import heapq
import itertools
if host == '':
hosts = [None]
elif (isinstance(host, str) or
- not isinstance(host, collections.Iterable)):
+ not isinstance(host, collections.abc.Iterable)):
hosts = [host]
else:
hosts = host
# =======
from io import StringIO, BytesIO, TextIOWrapper
-from collections import Mapping
+from collections.abc import Mapping
import sys
import os
import urllib.parse
import ast as _ast
import io as _io
import os as _os
-import collections
+import collections.abc
__all__ = ["error", "open"]
error = OSError
-class _Database(collections.MutableMapping):
+class _Database(collections.abc.MutableMapping):
# The on-disk directory and data files can remain in mutually
# inconsistent states for an arbitrarily long time (see comments
import io
import re
import socket
-import collections
+import collections.abc
from urllib.parse import urlsplit
# HTTPMessage, parse_headers(), and the HTTP status code constants are
try:
self.sock.sendall(data)
except TypeError:
- if isinstance(data, collections.Iterable):
+ if isinstance(data, collections.abc.Iterable):
for d in data:
self.sock.sendall(d)
else:
-from collections import Mapping
+from collections.abc import Mapping
import re
import sys
operator.irepeat(obj, n) -> operator.imul(obj, n)
"""
-import collections
+import collections.abc
# Local imports
from lib2to3 import fixer_base
def _check_method(self, node, results):
method = getattr(self, "_" + results["method"][0].value)
- if isinstance(method, collections.Callable):
+ if isinstance(method, collections.abc.Callable):
if "module" in results:
return method
else:
import encodings
import encodings.aliases
import re
-import collections
+import collections.abc
from builtins import str as _builtin_str
import functools
import warnings
percents = list(_percent_re.finditer(f))
new_f = _percent_re.sub('%s', f)
- if isinstance(val, collections.Mapping):
+ if isinstance(val, collections.abc.Mapping):
new_val = []
for perc in percents:
if perc.group()[-1]=='%':
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
# to hasattr(args[0], '__getitem__'). However, the docs on string
# formatting still seem to suggest a mapping object is required.
# Thus, while not removing the isinstance check, it does now look
- # for collections.Mapping rather than, as before, dict.
- if (args and len(args) == 1 and isinstance(args[0], collections.Mapping)
+ # for collections.abc.Mapping rather than, as before, dict.
+ if (args and len(args) == 1 and isinstance(args[0], collections.abc.Mapping)
and args[0]):
args = args[0]
self.args = args
import posixpath
import re
import sys
-from collections import Sequence
+from collections.abc import Sequence
from errno import EINVAL, ENOENT, ENOTDIR
from operator import attrgetter
from stat import S_ISDIR, S_ISLNK, S_ISREG, S_ISSOCK, S_ISBLK, S_ISCHR, S_ISFIFO
from abc import ABCMeta, abstractmethod
-from collections import namedtuple, Mapping
+from collections import namedtuple
+from collections.abc import Mapping
import math
import select
import sys
from pickle import Pickler, Unpickler
from io import BytesIO
-import collections
+import collections.abc
__all__ = ["Shelf", "BsdDbShelf", "DbfilenameShelf", "open"]
-class _ClosedDict(collections.MutableMapping):
+class _ClosedDict(collections.abc.MutableMapping):
'Marker for a closed dict. Access attempts raise a ValueError.'
def closed(self, *args):
return '<Closed Dictionary>'
-class Shelf(collections.MutableMapping):
+class Shelf(collections.abc.MutableMapping):
"""Base class for shelf implementations.
This is initialized with a dictionary-like object.
-import collections
+import collections.abc
import copy
import pickle
import unittest
def test_abc_registry(self):
d = dict(a=1)
- self.assertIsInstance(d.keys(), collections.KeysView)
- self.assertIsInstance(d.keys(), collections.MappingView)
- self.assertIsInstance(d.keys(), collections.Set)
- self.assertIsInstance(d.keys(), collections.Sized)
- self.assertIsInstance(d.keys(), collections.Iterable)
- self.assertIsInstance(d.keys(), collections.Container)
-
- self.assertIsInstance(d.values(), collections.ValuesView)
- self.assertIsInstance(d.values(), collections.MappingView)
- self.assertIsInstance(d.values(), collections.Sized)
-
- self.assertIsInstance(d.items(), collections.ItemsView)
- self.assertIsInstance(d.items(), collections.MappingView)
- self.assertIsInstance(d.items(), collections.Set)
- self.assertIsInstance(d.items(), collections.Sized)
- self.assertIsInstance(d.items(), collections.Iterable)
- self.assertIsInstance(d.items(), collections.Container)
+ self.assertIsInstance(d.keys(), collections.abc.KeysView)
+ self.assertIsInstance(d.keys(), collections.abc.MappingView)
+ self.assertIsInstance(d.keys(), collections.abc.Set)
+ self.assertIsInstance(d.keys(), collections.abc.Sized)
+ self.assertIsInstance(d.keys(), collections.abc.Iterable)
+ self.assertIsInstance(d.keys(), collections.abc.Container)
+
+ self.assertIsInstance(d.values(), collections.abc.ValuesView)
+ self.assertIsInstance(d.values(), collections.abc.MappingView)
+ self.assertIsInstance(d.values(), collections.abc.Sized)
+
+ self.assertIsInstance(d.items(), collections.abc.ItemsView)
+ self.assertIsInstance(d.items(), collections.abc.MappingView)
+ self.assertIsInstance(d.items(), collections.abc.Set)
+ self.assertIsInstance(d.items(), collections.abc.Sized)
+ self.assertIsInstance(d.items(), collections.abc.Iterable)
+ self.assertIsInstance(d.items(), collections.abc.Container)
if __name__ == "__main__":
import abc
import builtins
import collections
+import collections.abc
import copy
from itertools import permutations
import pickle
key = self.cmp_to_key(mycmp)
k = key(10)
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')
def test_compose_mro(self):
# None of the examples in this test depend on haystack ordering.
- c = collections
+ c = collections.abc
mro = functools._compose_mro
bases = [c.Sequence, c.MutableMapping, c.Mapping, c.Set]
for haystack in permutations(bases):
self.assertEqual(m, [dict, c.MutableMapping, c.Mapping,
c.Collection, c.Sized, c.Iterable,
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):
- m = mro(c.ChainMap, haystack)
- self.assertEqual(m, [c.ChainMap, c.MutableMapping, c.Mapping,
+ m = mro(collections.ChainMap, haystack)
+ self.assertEqual(m, [collections.ChainMap, c.MutableMapping, c.Mapping,
c.Collection, c.Sized, c.Iterable,
c.Container, object])
# test_mro_conflicts).
bases = [c.Container, c.Sized, str]
for haystack in permutations(bases):
- m = mro(c.defaultdict, [c.Sized, c.Container, str])
- self.assertEqual(m, [c.defaultdict, dict, c.Sized, c.Container,
- object])
+ m = mro(collections.defaultdict, [c.Sized, c.Container, str])
+ self.assertEqual(m, [collections.defaultdict, dict, c.Sized,
+ c.Container, object])
# MutableSequence below is registered directly on D. In other words, it
# precedes MutableMapping which means single dispatch will always
# choose MutableSequence here.
- class D(c.defaultdict):
+ class D(collections.defaultdict):
pass
c.MutableSequence.register(D)
bases = [c.MutableSequence, c.MutableMapping]
for haystack in permutations(bases):
m = mro(D, bases)
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,
object])
# Container and Callable are registered on different base classes and
# a generic function supporting both should always pick the Callable
# implementation if a C instance is passed.
- class C(c.defaultdict):
+ class C(collections.defaultdict):
def __call__(self):
pass
bases = [c.Sized, c.Callable, c.Container, c.Mapping]
for haystack in permutations(bases):
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.Container, object])
def test_register_abc(self):
- c = collections
+ c = collections.abc
d = {"a": "b"}
l = [1, 2, 3]
s = {object(), None}
self.assertEqual(g(s), "sized")
self.assertEqual(g(f), "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(l), "sized")
self.assertEqual(g(s), "sized")
self.assertEqual(g(t), "tuple")
def test_c3_abc(self):
- c = collections
+ c = collections.abc
mro = functools._c3_mro
class A(object):
pass
self.assertEqual(fun(aa), 'fun A')
def test_mro_conflicts(self):
- c = collections
+ c = collections.abc
@functools.singledispatch
def g(arg):
return "base"
# MutableMapping's bases implicit as well from defaultdict's
# perspective.
with self.assertRaises(RuntimeError) as re_two:
- h(c.defaultdict(lambda: 0))
+ h(collections.defaultdict(lambda: 0))
self.assertIn(
str(re_two.exception),
(("Ambiguous dispatch: <class 'collections.abc.Container'> "
("Ambiguous dispatch: <class 'collections.abc.Sized'> "
"or <class 'collections.abc.Container'>")),
)
- class R(c.defaultdict):
+ class R(collections.defaultdict):
pass
c.MutableSequence.register(R)
@functools.singledispatch
_orig_wkd = functools.WeakKeyDictionary
td = TracingDict()
functools.WeakKeyDictionary = lambda: td
- c = collections
+ c = collections.abc
@functools.singledispatch
def g(arg):
return "base"
import sys
import unittest
from test.support.script_helper import assert_python_ok
-from collections import Hashable
+from collections.abc import Hashable
IS_64BIT = sys.maxsize > 2**32
-import collections
+import collections.abc
import io
import os
import errno
P = self.cls
p = P(BASE)
it = p.glob("fileA")
- self.assertIsInstance(it, collections.Iterator)
+ self.assertIsInstance(it, collections.abc.Iterator)
_check(it, ["fileA"])
_check(p.glob("fileB"), [])
_check(p.glob("dir*/file*"), ["dirB/fileB", "dirC/fileC"])
P = self.cls
p = P(BASE)
it = p.rglob("fileA")
- self.assertIsInstance(it, collections.Iterator)
+ self.assertIsInstance(it, collections.abc.Iterator)
_check(it, ["fileA"])
_check(p.rglob("fileB"), ["dirB/fileB"])
_check(p.rglob("*/fileA"), [])
"""
import collections
+import collections.abc
import decimal
import doctest
import math
if rel is None:
rel = self.rel
if (
- isinstance(first, collections.Sequence) and
- isinstance(second, collections.Sequence)
+ isinstance(first, collections.abc.Sequence) and
+ isinstance(second, collections.abc.Sequence)
):
check = self._check_approx_seq
else:
self.assertIsSubclass(MMC, 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(MMB, collections.Mapping)
- self.assertIsSubclass(MMC, collections.Mapping)
+ self.assertIsSubclass(MMA, collections_abc.Mapping)
+ self.assertIsSubclass(MMB, collections_abc.Mapping)
+ self.assertIsSubclass(MMC, collections_abc.Mapping)
self.assertIsSubclass(MMB[str, str], typing.Mapping)
self.assertIsSubclass(MMC, MMA)
def g(): yield 0
self.assertIsSubclass(G, typing.Generator)
self.assertIsSubclass(G, typing.Iterable)
- if hasattr(collections, 'Generator'):
- self.assertIsSubclass(G, collections.Generator)
- self.assertIsSubclass(G, collections.Iterable)
+ if hasattr(collections_abc, 'Generator'):
+ self.assertIsSubclass(G, collections_abc.Generator)
+ self.assertIsSubclass(G, collections_abc.Iterable)
self.assertNotIsSubclass(type(g), G)
@skipUnless(PY36, 'Python 3.6 required')
g = ns['g']
self.assertIsSubclass(G, typing.AsyncGenerator)
self.assertIsSubclass(G, typing.AsyncIterable)
- self.assertIsSubclass(G, collections.AsyncGenerator)
- self.assertIsSubclass(G, collections.AsyncIterable)
+ self.assertIsSubclass(G, collections_abc.AsyncGenerator)
+ self.assertIsSubclass(G, collections_abc.AsyncIterable)
self.assertNotIsSubclass(type(g), G)
instance = G()
self.assertIsInstance(instance, typing.AsyncGenerator)
self.assertIsInstance(instance, typing.AsyncIterable)
- self.assertIsInstance(instance, collections.AsyncGenerator)
- self.assertIsInstance(instance, collections.AsyncIterable)
+ self.assertIsInstance(instance, collections_abc.AsyncGenerator)
+ self.assertIsInstance(instance, collections_abc.AsyncIterable)
self.assertNotIsInstance(type(g), G)
self.assertNotIsInstance(g, G)
self.assertIsSubclass(D, B)
class M(): ...
- collections.MutableMapping.register(M)
+ collections_abc.MutableMapping.register(M)
self.assertIsSubclass(M, typing.Mapping)
def test_collections_as_base(self):
- class M(collections.Mapping): ...
+ class M(collections_abc.Mapping): ...
self.assertIsSubclass(M, typing.Mapping)
self.assertIsSubclass(M, typing.Iterable)
- class S(collections.MutableSequence): ...
+ class S(collections_abc.MutableSequence): ...
self.assertIsSubclass(S, typing.MutableSequence)
self.assertIsSubclass(S, typing.Iterable)
- class I(collections.Iterable): ...
+ class I(collections_abc.Iterable): ...
self.assertIsSubclass(I, typing.Iterable)
- class A(collections.Mapping, metaclass=abc.ABCMeta): ...
+ class A(collections_abc.Mapping, metaclass=abc.ABCMeta): ...
class B: ...
A.register(B)
self.assertIsSubclass(B, typing.Mapping)
-from collections import Sequence, Iterable
+from collections.abc import Sequence, Iterable
from functools import total_ordering
import fnmatch
import linecache
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 itertools
__hash__ = ref.__hash__
-class WeakValueDictionary(collections.MutableMapping):
+class WeakValueDictionary(collections.abc.MutableMapping):
"""Mapping class that references values weakly.
Entries in the dictionary will be discarded when no strong
super().__init__(ob, callback)
-class WeakKeyDictionary(collections.MutableMapping):
+class WeakKeyDictionary(collections.abc.MutableMapping):
""" Mapping class that references keys weakly.
Entries in the dictionary will be discarded when there is no
import warnings
import io
import collections
+import collections.abc
import contextlib
from . import ElementPath
if close_source:
source.close()
- class IterParseIterator(collections.Iterator):
+ class IterParseIterator(collections.abc.Iterator):
__next__ = iterator().__next__
it = IterParseIterator()
it.root = None
projects / python / commitdiff