3792175048

Build Type

push

github

Committed by GitHub

Commit Message

Drop support for Python 2.7, 3.5, 3.6. (#266)

Run Details

1772 of 1802 branches covered (98.34%)

Branch coverage included in aggregate %.

600 of 602 new or added lines in 30 files covered. (99.67%)

21 existing lines in 5 files now uncovered.

12095 of 12206 relevant lines covered (99.09%)

5.91 hits per line

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

92.23

/src/zope/interface/exceptions.py

##############################################################################
#
# Copyright (c) 2002 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-specific exceptions
"""

__all__ = [
    # Invalid tree
    'Invalid',
    'DoesNotImplement',
    'BrokenImplementation',
    'BrokenMethodImplementation',
    'MultipleInvalid',
    # Other
    'BadImplements',
    'InvalidInterface',
]

class Invalid(Exception):
    """A specification is violated
    """


class _TargetInvalid(Invalid):
    # Internal use. Subclass this when you're describing
    # a particular target object that's invalid according
    # to a specific interface.
    #
    # For backwards compatibility, the *target* and *interface* are
    # optional, and the signatures are inconsistent in their ordering.
    #
    # We deal with the inconsistency in ordering by defining the index
    # of the two values in ``self.args``. *target* uses a marker object to
    # distinguish "not given" from "given, but None", because the latter
    # can be a value that gets passed to validation. For this reason, it must
    # always be the last argument (we detect absence by the ``IndexError``).

    _IX_INTERFACE = 0
    _IX_TARGET = 1
    # The exception to catch when indexing self.args indicating that
    # an argument was not given. If all arguments are expected,
    # a subclass should set this to ().
    _NOT_GIVEN_CATCH = IndexError
    _NOT_GIVEN = '<Not Given>'

    def _get_arg_or_default(self, ix, default=None):
        try:
            return self.args[ix] # pylint:disable=unsubscriptable-object
        except self._NOT_GIVEN_CATCH:
            return default

    @property
    def interface(self):
        return self._get_arg_or_default(self._IX_INTERFACE)

    @property
    def target(self):
        return self._get_arg_or_default(self._IX_TARGET, self._NOT_GIVEN)

    ###
    # str
    #
    # The ``__str__`` of self is implemented by concatenating (%s), in order,
    # these properties (none of which should have leading or trailing
    # whitespace):
    #
    # - self._str_subject
    #   Begin the message, including a description of the target.
    # - self._str_description
    #   Provide a general description of the type of error, including
    #   the interface name if possible and relevant.
    # - self._str_conjunction
    #   Join the description to the details. Defaults to ": ".
    # - self._str_details
    #   Provide details about how this particular instance of the error.
    # - self._str_trailer
    #   End the message. Usually just a period.
    ###

    @property
    def _str_subject(self):
        target = self.target
        if target is self._NOT_GIVEN:
            return "An object"
        return "The object {!r}".format(target)

    @property
    def _str_description(self):
        return "has failed to implement interface %s" % (
            self.interface or '<Unknown>'
        )

    _str_conjunction = ": "
    _str_details = "<unknown>"
    _str_trailer = '.'

    def __str__(self):
        return "{} {}{}{}{}".format(
            self._str_subject,
            self._str_description,
            self._str_conjunction,
            self._str_details,
            self._str_trailer
        )


class DoesNotImplement(_TargetInvalid):
    """
    DoesNotImplement(interface[, target])

    The *target* (optional) does not implement the *interface*.

    .. versionchanged:: 5.0.0
       Add the *target* argument and attribute, and change the resulting
       string value of this object accordingly.
    """

    _str_details = "Does not declaratively implement the interface"


class BrokenImplementation(_TargetInvalid):
    """
    BrokenImplementation(interface, name[, target])

    The *target* (optional) is missing the attribute *name*.

    .. versionchanged:: 5.0.0
       Add the *target* argument and attribute, and change the resulting
       string value of this object accordingly.

       The *name* can either be a simple string or a ``Attribute`` object.
    """

    _IX_NAME = _TargetInvalid._IX_INTERFACE + 1
    _IX_TARGET = _IX_NAME + 1

    @property
    def name(self):
        return self.args[1] # pylint:disable=unsubscriptable-object

    @property
    def _str_details(self):
        return "The %s attribute was not provided" % (
            repr(self.name) if isinstance(self.name, str) else self.name
        )


class BrokenMethodImplementation(_TargetInvalid):
    """
    BrokenMethodImplementation(method, message[, implementation, interface, target])

    The *target* (optional) has a *method* in *implementation* that violates
    its contract in a way described by *mess*.

    .. versionchanged:: 5.0.0
       Add the *interface* and *target* argument and attribute,
       and change the resulting string value of this object accordingly.

       The *method* can either be a simple string or a ``Method`` object.

    .. versionchanged:: 5.0.0
       If *implementation* is given, then the *message* will have the
       string "implementation" replaced with an short but informative
       representation of *implementation*.

    """

    _IX_IMPL = 2
    _IX_INTERFACE = _IX_IMPL + 1
    _IX_TARGET = _IX_INTERFACE + 1

    @property
    def method(self):
        return self.args[0] # pylint:disable=unsubscriptable-object

    @property
    def mess(self):
        return self.args[1] # pylint:disable=unsubscriptable-object

    @staticmethod
    def __implementation_str(impl):
        # It could be a callable or some arbitrary object, we don't
        # know yet.
        import inspect # Inspect is a heavy-weight dependency, lots of imports
        try:
            sig = inspect.signature
            formatsig = str
        except AttributeError:
            sig = inspect.getargspec
            f = inspect.formatargspec
            formatsig = lambda sig: f(*sig) # pylint:disable=deprecated-method

        try:
            sig = sig(impl)
        except (ValueError, TypeError):
            # Unable to introspect. Darn.
            # This could be a non-callable, or a particular builtin,
            # or a bound method that doesn't even accept 'self', e.g.,
            # ``Class.method = lambda: None; Class().method``
            return repr(impl)

        try:
            name = impl.__qualname__
        except AttributeError:
            name = impl.__name__

        return name + formatsig(sig)

    @property
    def _str_details(self):
        impl = self._get_arg_or_default(self._IX_IMPL, self._NOT_GIVEN)
        message = self.mess
        if impl is not self._NOT_GIVEN and 'implementation' in message:
            message = message.replace("implementation", '%r')
            message = message % (self.__implementation_str(impl),)

        return 'The contract of {} is violated because {}'.format(
            repr(self.method) if isinstance(self.method, str) else self.method,
            message,
        )


class MultipleInvalid(_TargetInvalid):
    """
    The *target* has failed to implement the *interface* in
    multiple ways.

    The failures are described by *exceptions*, a collection of
    other `Invalid` instances.

    .. versionadded:: 5.0
    """

    _NOT_GIVEN_CATCH = ()

    def __init__(self, interface, target, exceptions):
        super().__init__(interface, target, tuple(exceptions))

    @property
    def exceptions(self):
        return self.args[2] # pylint:disable=unsubscriptable-object

    @property
    def _str_details(self):
        # It would be nice to use tabs here, but that
        # is hard to represent in doctests.
        return '\n    ' + '\n    '.join(
            x._str_details.strip() if isinstance(x, _TargetInvalid) else str(x)
            for x in self.exceptions
        )

    _str_conjunction = ':' # We don't want a trailing space, messes up doctests
    _str_trailer = ''


class InvalidInterface(Exception):
    """The interface has invalid contents
    """

class BadImplements(TypeError):
    """An implementation assertion is invalid

    because it doesn't contain an interface or a sequence of valid
    implementation assertions.
    """

1	##############################################################################
2	#
3	# Copyright (c) 2002 Zope Foundation and Contributors.
4	# All Rights Reserved.
5	#
6	# This software is subject to the provisions of the Zope Public License,
7	# Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution.
8	# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
9	# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
10	# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
11	# FOR A PARTICULAR PURPOSE.
12	#
13	##############################################################################
14	"""Interface-specific exceptions	6✔
15	"""
16
17	__all__ = [	6✔
18	# Invalid tree
19	'Invalid',
20	'DoesNotImplement',
21	'BrokenImplementation',
22	'BrokenMethodImplementation',
23	'MultipleInvalid',
24	# Other
25	'BadImplements',
26	'InvalidInterface',
27	]
28
29	class Invalid(Exception):	6✔
30	"""A specification is violated
31	"""
32
33
34	class _TargetInvalid(Invalid):	6✔
35	# Internal use. Subclass this when you're describing
36	# a particular target object that's invalid according
37	# to a specific interface.
38	#
39	# For backwards compatibility, the target and interface are
40	# optional, and the signatures are inconsistent in their ordering.
41	#
42	# We deal with the inconsistency in ordering by defining the index
43	# of the two values in ``self.args``. target uses a marker object to
44	# distinguish "not given" from "given, but None", because the latter
45	# can be a value that gets passed to validation. For this reason, it must
46	# always be the last argument (we detect absence by the ``IndexError``).
47
48	_IX_INTERFACE = 0	6✔
49	_IX_TARGET = 1	6✔
50	# The exception to catch when indexing self.args indicating that
51	# an argument was not given. If all arguments are expected,
52	# a subclass should set this to ().
53	_NOT_GIVEN_CATCH = IndexError	6✔
54	_NOT_GIVEN = '<Not Given>'	6✔
55
56	def _get_arg_or_default(self, ix, default=None):	6✔
57	try:	6✔
58	return self.args[ix] # pylint:disable=unsubscriptable-object	6✔
59	except self._NOT_GIVEN_CATCH:	6✔
60	return default	6✔
61
62	@property	6✔
63	def interface(self):	4✔
64	return self._get_arg_or_default(self._IX_INTERFACE)	6✔
65
66	@property	6✔
67	def target(self):	4✔
68	return self._get_arg_or_default(self._IX_TARGET, self._NOT_GIVEN)	6✔
69
70	###
71	# str
72	#
73	# The ``__str__`` of self is implemented by concatenating (%s), in order,
74	# these properties (none of which should have leading or trailing
75	# whitespace):
76	#
77	# - self._str_subject
78	# Begin the message, including a description of the target.
79	# - self._str_description
80	# Provide a general description of the type of error, including
81	# the interface name if possible and relevant.
82	# - self._str_conjunction
83	# Join the description to the details. Defaults to ": ".
84	# - self._str_details
85	# Provide details about how this particular instance of the error.
86	# - self._str_trailer
87	# End the message. Usually just a period.
88	###
89
90	@property	6✔
91	def _str_subject(self):	4✔
92	target = self.target	6✔
93	if target is self._NOT_GIVEN:	6✔
94	return "An object"	6✔
95	return "The object {!r}".format(target)	6✔
96
97	@property	6✔
98	def _str_description(self):	4✔
99	return "has failed to implement interface %s" % (	6✔
100	self.interface or '<Unknown>'
101	)
102
103	_str_conjunction = ": "	6✔
104	_str_details = "<unknown>"	6✔
105	_str_trailer = '.'	6✔
106
107	def __str__(self):	6✔
108	return "{} {}{}{}{}".format(	6✔
109	self._str_subject,
110	self._str_description,
111	self._str_conjunction,
112	self._str_details,
113	self._str_trailer
114	)
115
116
117	class DoesNotImplement(_TargetInvalid):	6✔
118	"""
119	DoesNotImplement(interface[, target])
120
121	The target (optional) does not implement the interface.
122
123	.. versionchanged:: 5.0.0
124	Add the target argument and attribute, and change the resulting
125	string value of this object accordingly.
126	"""
127
128	_str_details = "Does not declaratively implement the interface"	6✔
129
130
131	class BrokenImplementation(_TargetInvalid):	6✔
132	"""
133	BrokenImplementation(interface, name[, target])
134
135	The target (optional) is missing the attribute name.
136
137	.. versionchanged:: 5.0.0
138	Add the target argument and attribute, and change the resulting
139	string value of this object accordingly.
140
141	The name can either be a simple string or a ``Attribute`` object.
142	"""
143
144	_IX_NAME = _TargetInvalid._IX_INTERFACE + 1	6✔
145	_IX_TARGET = _IX_NAME + 1	6✔
146
147	@property	6✔
148	def name(self):	4✔
149	return self.args[1] # pylint:disable=unsubscriptable-object	6✔
150
151	@property	6✔
152	def _str_details(self):	4✔
153	return "The %s attribute was not provided" % (	6✔
154	repr(self.name) if isinstance(self.name, str) else self.name
155	)
156
157
158	class BrokenMethodImplementation(_TargetInvalid):	6✔
159	"""
160	BrokenMethodImplementation(method, message[, implementation, interface, target])
161
162	The target (optional) has a method in implementation that violates
163	its contract in a way described by mess.
164
165	.. versionchanged:: 5.0.0
166	Add the interface and target argument and attribute,
167	and change the resulting string value of this object accordingly.
168
169	The method can either be a simple string or a ``Method`` object.
170
171	.. versionchanged:: 5.0.0
172	If implementation is given, then the message will have the
173	string "implementation" replaced with an short but informative
174	representation of implementation.
175
176	"""
177
178	_IX_IMPL = 2	6✔
179	_IX_INTERFACE = _IX_IMPL + 1	6✔
180	_IX_TARGET = _IX_INTERFACE + 1	6✔
181
182	@property	6✔
183	def method(self):	4✔
184	return self.args[0] # pylint:disable=unsubscriptable-object	6✔
185
186	@property	6✔
187	def mess(self):	4✔
188	return self.args[1] # pylint:disable=unsubscriptable-object	6✔
189
190	@staticmethod	6✔
191	def __implementation_str(impl):	4✔
192	# It could be a callable or some arbitrary object, we don't
193	# know yet.
194	import inspect # Inspect is a heavy-weight dependency, lots of imports	6✔
195	try:	6✔
196	sig = inspect.signature	6✔
197	formatsig = str	6✔
UNCOV 198	except AttributeError:	×
UNCOV 199	sig = inspect.getargspec	×
UNCOV 200	f = inspect.formatargspec	×
UNCOV 201	formatsig = lambda sig: f(*sig) # pylint:disable=deprecated-method	×
202
203	try:	6✔
204	sig = sig(impl)	6✔
205	except (ValueError, TypeError):	6✔
206	# Unable to introspect. Darn.
207	# This could be a non-callable, or a particular builtin,
208	# or a bound method that doesn't even accept 'self', e.g.,
209	# ``Class.method = lambda: None; Class().method``
210	return repr(impl)	6✔
211
212	try:	6✔
213	name = impl.__qualname__	6✔
UNCOV 214	except AttributeError:	×
UNCOV 215	name = impl.__name__	×
216
217	return name + formatsig(sig)	6✔
218
219	@property	6✔
220	def _str_details(self):	4✔
221	impl = self._get_arg_or_default(self._IX_IMPL, self._NOT_GIVEN)	6✔
222	message = self.mess	6✔
223	if impl is not self._NOT_GIVEN and 'implementation' in message:	6✔
224	message = message.replace("implementation", '%r')	6✔
225	message = message % (self.__implementation_str(impl),)	6✔
226
227	return 'The contract of {} is violated because {}'.format(	6✔
228	repr(self.method) if isinstance(self.method, str) else self.method,
229	message,
230	)
231
232
233	class MultipleInvalid(_TargetInvalid):	6✔
234	"""
235	The target has failed to implement the interface in
236	multiple ways.
237
238	The failures are described by exceptions, a collection of
239	other `Invalid` instances.
240
241	.. versionadded:: 5.0
242	"""
243
244	_NOT_GIVEN_CATCH = ()	6✔
245
246	def __init__(self, interface, target, exceptions):	6✔
247	super().__init__(interface, target, tuple(exceptions))	6✔
248
249	@property	6✔
250	def exceptions(self):	4✔
251	return self.args[2] # pylint:disable=unsubscriptable-object	6✔
252
253	@property	6✔
254	def _str_details(self):	4✔
255	# It would be nice to use tabs here, but that
256	# is hard to represent in doctests.
257	return '\n ' + '\n '.join(	6✔
258	x._str_details.strip() if isinstance(x, _TargetInvalid) else str(x)
259	for x in self.exceptions
260	)
261
262	_str_conjunction = ':' # We don't want a trailing space, messes up doctests	6✔
263	_str_trailer = ''	6✔
264
265
266	class InvalidInterface(Exception):	6✔
267	"""The interface has invalid contents
268	"""
269
270	class BadImplements(TypeError):	6✔
271	"""An implementation assertion is invalid
272
273	because it doesn't contain an interface or a sequence of valid
274	implementation assertions.
275	"""

zopefoundation / zope.interface / 3792175048

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