12026404035

Committed 26 Nov 2024 08:12AM UTC coverage: 99.023% (+0.002%) from 99.021%

Build # 12026404035

Build Type

Pull #335

github

Committed by

icemac

Commit Message

Preliminary support for Python 3.14a2.

Fixes #334.

Pull Request Pull Request #335: Preliminary support for Python 3.14a2.

Run Details

1660 of 1688 branches covered (98.34%)

Branch coverage included in aggregate %.

15 of 15 new or added lines in 4 files covered. (100.0%)

5 existing lines in 2 files now uncovered.

12229 of 12338 relevant lines covered (99.12%)

7.92 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

93.64

/src/zope/interface/common/collections.py

##############################################################################
# Copyright (c) 2020 Zope Foundation and Contributors.
# All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE.
##############################################################################
"""
Interface definitions paralleling the abstract base classes defined in
:mod:`collections.abc`.

After this module is imported, the standard library types will declare that
they implement the appropriate interface. While most standard library types
will properly implement that interface (that is, ``verifyObject(ISequence,
list()))`` will pass, for example), a few might not:

    - `memoryview` doesn't feature all the defined methods of
      ``ISequence`` such as ``count``; it is still declared to provide
      ``ISequence`` though.

    - `collections.deque.pop` doesn't accept the ``index`` argument of
      `collections.abc.MutableSequence.pop`

    - `range.index` does not accept the ``start`` and ``stop`` arguments.

.. versionadded:: 5.0.0
"""

import sys
from abc import ABCMeta
from collections import OrderedDict
from collections import UserDict
from collections import UserList
from collections import UserString
from collections import abc

from zope.interface._compat import PY38
from zope.interface._compat import PY39
from zope.interface._compat import PY310
from zope.interface._compat import PY311
from zope.interface._compat import PY312
from zope.interface._compat import PY313
from zope.interface.common import ABCInterface
from zope.interface.common import optional


# pylint:disable=inherit-non-class,
# pylint:disable=no-self-argument,no-method-argument
# pylint:disable=unexpected-special-method-signature
# pylint:disable=no-value-for-parameter


def _new_in_ver(name, ver,
                bases_if_missing=(ABCMeta,),
                register_if_missing=()):
    if ver:
        return getattr(abc, name)

    # TODO: It's a shame to have to repeat the bases when
    # the ABC is missing. Can we DRY that?
    missing = ABCMeta(name, bases_if_missing, {
        '__doc__': "The ABC %s is not defined in this version of Python." % (
            name
        ),
    })

    for c in register_if_missing:
        missing.register(c)

    return missing


__all__ = [
    'IAsyncGenerator',
    'IAsyncIterable',
    'IAsyncIterator',
    'IAwaitable',
    'ICollection',
    'IContainer',
    'ICoroutine',
    'IGenerator',
    'IHashable',
    'IItemsView',
    'IIterable',
    'IIterator',
    'IKeysView',
    'IMapping',
    'IMappingView',
    'IMutableMapping',
    'IMutableSequence',
    'IMutableSet',
    'IReversible',
    'ISequence',
    'ISet',
    'ISized',
    'IValuesView',
]


class IContainer(ABCInterface):
    abc = abc.Container

    @optional
    def __contains__(other):
        """
        Optional method. If not provided, the interpreter will use
        ``__iter__`` or the old ``__getitem__`` protocol
        to implement ``in``.
        """


class IHashable(ABCInterface):
    abc = abc.Hashable


class IIterable(ABCInterface):
    abc = abc.Iterable

    @optional
    def __iter__():
        """
        Optional method. If not provided, the interpreter will
        implement `iter` using the old ``__getitem__`` protocol.
        """


class IIterator(IIterable):
    abc = abc.Iterator


class IReversible(IIterable):
    abc = _new_in_ver('Reversible', True, (IIterable.getABC(),))

    @optional
    def __reversed__():
        """
        Optional method. If this isn't present, the interpreter
        will use ``__len__`` and ``__getitem__`` to implement the
        `reversed` builtin.
        """


class IGenerator(IIterator):
    # New in Python 3.5
    abc = _new_in_ver('Generator', True, (IIterator.getABC(),))


class ISized(ABCInterface):
    abc = abc.Sized


# ICallable is not defined because there's no standard signature.


class ICollection(ISized,
                  IIterable,
                  IContainer):
    abc = _new_in_ver(
        'Collection',
        True,
        (ISized.getABC(), IIterable.getABC(), IContainer.getABC())
    )


class ISequence(IReversible,
                ICollection):
    abc = abc.Sequence
    extra_classes = (UserString,)
    # On Python 2, basestring was registered as an ISequence, and
    # its subclass str is an IByteString. If we also register str as
    # an ISequence, that tends to lead to inconsistent resolution order.
    ignored_classes = ()

    @optional
    def __reversed__():
        """
        Optional method. If this isn't present, the interpreter
        will use ``__len__`` and ``__getitem__`` to implement the
        `reversed` builtin.
        """

    @optional
    def __iter__():
        """
        Optional method. If not provided, the interpreter will
        implement `iter` using the old ``__getitem__`` protocol.
        """


class IMutableSequence(ISequence):
    abc = abc.MutableSequence
    extra_classes = (UserList,)


if PY38 or PY39 or PY310 or PY311 or PY312 or PY313:
    class IByteString(ISequence):
        """
        This unifies `bytes` and `bytearray`.
        """
        abc = _new_in_ver(
            'ByteString', True, (ISequence.getABC(),), (bytes, bytearray),
        )


class ISet(ICollection):
    abc = abc.Set


class IMutableSet(ISet):
    abc = abc.MutableSet


class IMapping(ICollection):
    abc = abc.Mapping
    extra_classes = (dict,)
    # OrderedDict is a subclass of dict. On CPython 2,
    # it winds up registered as a IMutableMapping, which
    # produces an inconsistent IRO if we also try to register it
    # here.
    ignored_classes = (OrderedDict,)


class IMutableMapping(IMapping):
    abc = abc.MutableMapping
    extra_classes = (dict, UserDict,)
    ignored_classes = (OrderedDict,)


class IMappingView(ISized):
    abc = abc.MappingView


class IItemsView(IMappingView, ISet):
    abc = abc.ItemsView


class IKeysView(IMappingView, ISet):
    abc = abc.KeysView


class IValuesView(IMappingView, ICollection):
    abc = abc.ValuesView

    @optional
    def __contains__(other):
        """
        Optional method. If not provided, the interpreter will use
        ``__iter__`` or the old ``__len__`` and ``__getitem__`` protocol
        to implement ``in``.
        """


class IAwaitable(ABCInterface):
    abc = _new_in_ver('Awaitable', True)


class ICoroutine(IAwaitable):
    abc = _new_in_ver('Coroutine', True)


class IAsyncIterable(ABCInterface):
    abc = _new_in_ver('AsyncIterable', True)


class IAsyncIterator(IAsyncIterable):
    abc = _new_in_ver('AsyncIterator', True)


class IAsyncGenerator(IAsyncIterator):
    abc = _new_in_ver('AsyncGenerator', True)

1	##############################################################################
2	# Copyright (c) 2020 Zope Foundation and Contributors.
3	# All Rights Reserved.
4	#
5	# This software is subject to the provisions of the Zope Public License,
6	# Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution.
7	# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
8	# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
9	# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
10	# FOR A PARTICULAR PURPOSE.
11	##############################################################################
12	"""	8✔
13	Interface definitions paralleling the abstract base classes defined in
14	:mod:`collections.abc`.
15
16	After this module is imported, the standard library types will declare that
17	they implement the appropriate interface. While most standard library types
18	will properly implement that interface (that is, ``verifyObject(ISequence,
19	list()))`` will pass, for example), a few might not:
20
21	- `memoryview` doesn't feature all the defined methods of
22	``ISequence`` such as ``count``; it is still declared to provide
23	``ISequence`` though.
24
25	- `collections.deque.pop` doesn't accept the ``index`` argument of
26	`collections.abc.MutableSequence.pop`
27
28	- `range.index` does not accept the ``start`` and ``stop`` arguments.
29
30	.. versionadded:: 5.0.0
31	"""
32
33	import sys	8✔
34	from abc import ABCMeta	8✔
35	from collections import OrderedDict	8✔
36	from collections import UserDict	8✔
37	from collections import UserList	8✔
38	from collections import UserString	8✔
39	from collections import abc	8✔
40
41	from zope.interface._compat import PY38	8✔
42	from zope.interface._compat import PY39	8✔
43	from zope.interface._compat import PY310	8✔
44	from zope.interface._compat import PY311	8✔
45	from zope.interface._compat import PY312	8✔
46	from zope.interface._compat import PY313	8✔
47	from zope.interface.common import ABCInterface	8✔
48	from zope.interface.common import optional	8✔
49
50
51	# pylint:disable=inherit-non-class,
52	# pylint:disable=no-self-argument,no-method-argument
53	# pylint:disable=unexpected-special-method-signature
54	# pylint:disable=no-value-for-parameter
55
56
57	def _new_in_ver(name, ver,	8✔
58	bases_if_missing=(ABCMeta,),
59	register_if_missing=()):
60	if ver:	8!
61	return getattr(abc, name)	8✔
62
63	# TODO: It's a shame to have to repeat the bases when
64	# the ABC is missing. Can we DRY that?
UNCOV 65	missing = ABCMeta(name, bases_if_missing, {	×
66	'__doc__': "The ABC %s is not defined in this version of Python." % (
67	name
68	),
69	})
70
UNCOV 71	for c in register_if_missing:	×
UNCOV 72	missing.register(c)	×
73
UNCOV 74	return missing	×
75
76
77	__all__ = [	8✔
78	'IAsyncGenerator',
79	'IAsyncIterable',
80	'IAsyncIterator',
81	'IAwaitable',
82	'ICollection',
83	'IContainer',
84	'ICoroutine',
85	'IGenerator',
86	'IHashable',
87	'IItemsView',
88	'IIterable',
89	'IIterator',
90	'IKeysView',
91	'IMapping',
92	'IMappingView',
93	'IMutableMapping',
94	'IMutableSequence',
95	'IMutableSet',
96	'IReversible',
97	'ISequence',
98	'ISet',
99	'ISized',
100	'IValuesView',
101	]
102
103
104	class IContainer(ABCInterface):	8✔
105	abc = abc.Container	8✔
106
107	@optional	8✔
108	def __contains__(other):	8✔
109	"""
110	Optional method. If not provided, the interpreter will use
111	``__iter__`` or the old ``__getitem__`` protocol
112	to implement ``in``.
113	"""
114
115
116	class IHashable(ABCInterface):	8✔
117	abc = abc.Hashable	8✔
118
119
120	class IIterable(ABCInterface):	8✔
121	abc = abc.Iterable	8✔
122
123	@optional	8✔
124	def __iter__():	8✔
125	"""
126	Optional method. If not provided, the interpreter will
127	implement `iter` using the old ``__getitem__`` protocol.
128	"""
129
130
131	class IIterator(IIterable):	8✔
132	abc = abc.Iterator	8✔
133
134
135	class IReversible(IIterable):	8✔
136	abc = _new_in_ver('Reversible', True, (IIterable.getABC(),))	8✔
137
138	@optional	8✔
139	def __reversed__():	8✔
140	"""
141	Optional method. If this isn't present, the interpreter
142	will use ``__len__`` and ``__getitem__`` to implement the
143	`reversed` builtin.
144	"""
145
146
147	class IGenerator(IIterator):	8✔
148	# New in Python 3.5
149	abc = _new_in_ver('Generator', True, (IIterator.getABC(),))	8✔
150
151
152	class ISized(ABCInterface):	8✔
153	abc = abc.Sized	8✔
154
155
156	# ICallable is not defined because there's no standard signature.
157
158
159	class ICollection(ISized,	8✔
160	IIterable,
161	IContainer):
162	abc = _new_in_ver(	8✔
163	'Collection',
164	True,
165	(ISized.getABC(), IIterable.getABC(), IContainer.getABC())
166	)
167
168
169	class ISequence(IReversible,	8✔
170	ICollection):
171	abc = abc.Sequence	8✔
172	extra_classes = (UserString,)	8✔
173	# On Python 2, basestring was registered as an ISequence, and
174	# its subclass str is an IByteString. If we also register str as
175	# an ISequence, that tends to lead to inconsistent resolution order.
176	ignored_classes = ()	8✔
177
178	@optional	8✔
179	def __reversed__():	8✔
180	"""
181	Optional method. If this isn't present, the interpreter
182	will use ``__len__`` and ``__getitem__`` to implement the
183	`reversed` builtin.
184	"""
185
186	@optional	8✔
187	def __iter__():	8✔
188	"""
189	Optional method. If not provided, the interpreter will
190	implement `iter` using the old ``__getitem__`` protocol.
191	"""
192
193
194	class IMutableSequence(ISequence):	8✔
195	abc = abc.MutableSequence	8✔
196	extra_classes = (UserList,)	8✔
197
198
199	if PY38 or PY39 or PY310 or PY311 or PY312 or PY313:	8✔
200	class IByteString(ISequence):	7✔
201	"""
202	This unifies `bytes` and `bytearray`.
203	"""
204	abc = _new_in_ver(	7✔
205	'ByteString', True, (ISequence.getABC(),), (bytes, bytearray),
206	)
207
208
209	class ISet(ICollection):	8✔
210	abc = abc.Set	8✔
211
212
213	class IMutableSet(ISet):	8✔
214	abc = abc.MutableSet	8✔
215
216
217	class IMapping(ICollection):	8✔
218	abc = abc.Mapping	8✔
219	extra_classes = (dict,)	8✔
220	# OrderedDict is a subclass of dict. On CPython 2,
221	# it winds up registered as a IMutableMapping, which
222	# produces an inconsistent IRO if we also try to register it
223	# here.
224	ignored_classes = (OrderedDict,)	8✔
225
226
227	class IMutableMapping(IMapping):	8✔
228	abc = abc.MutableMapping	8✔
229	extra_classes = (dict, UserDict,)	8✔
230	ignored_classes = (OrderedDict,)	8✔
231
232
233	class IMappingView(ISized):	8✔
234	abc = abc.MappingView	8✔
235
236
237	class IItemsView(IMappingView, ISet):	8✔
238	abc = abc.ItemsView	8✔
239
240
241	class IKeysView(IMappingView, ISet):	8✔
242	abc = abc.KeysView	8✔
243
244
245	class IValuesView(IMappingView, ICollection):	8✔
246	abc = abc.ValuesView	8✔
247
248	@optional	8✔
249	def __contains__(other):	8✔
250	"""
251	Optional method. If not provided, the interpreter will use
252	``__iter__`` or the old ``__len__`` and ``__getitem__`` protocol
253	to implement ``in``.
254	"""
255
256
257	class IAwaitable(ABCInterface):	8✔
258	abc = _new_in_ver('Awaitable', True)	8✔
259
260
261	class ICoroutine(IAwaitable):	8✔
262	abc = _new_in_ver('Coroutine', True)	8✔
263
264
265	class IAsyncIterable(ABCInterface):	8✔
266	abc = _new_in_ver('AsyncIterable', True)	8✔
267
268
269	class IAsyncIterator(IAsyncIterable):	8✔
270	abc = _new_in_ver('AsyncIterator', True)	8✔
271
272
273	class IAsyncGenerator(IAsyncIterator):	8✔
274	abc = _new_in_ver('AsyncGenerator', True)	8✔

zopefoundation / zope.interface / 12026404035

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous