3923311326

Build Type

push

github

Committed by GitHub

Commit Message

Merge pull request #54 from zopefoundation/config-with-c-code-template-f65feacc

Run Details

121 of 122 branches covered (99.18%)

Branch coverage included in aggregate %.

83 of 84 new or added lines in 3 files covered. (98.81%)

9 existing lines in 1 file now uncovered.

1459 of 1475 relevant lines covered (98.92%)

5.92 hits per line

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

95.18

/src/zope/proxy/__init__.py

##############################################################################
#
# Copyright (c) 2003 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.
#
##############################################################################
"""More convenience functions for dealing with proxies.
"""
import operator
import os
import pickle

from zope.interface import moduleProvides

from zope.proxy.interfaces import IProxyIntrospection


moduleProvides(IProxyIntrospection)
__all__ = tuple(IProxyIntrospection)


def ProxyIterator(p):
    yield p
    while isProxy(p):
        p = getProxiedObject(p)
        yield p


_MARKER = object()


def _WrapperType_Lookup(type_, name):
    """
    Looks up information in class dictionaries in MRO
    order, ignoring the proxy type itself.

    Returns the first found object, or _MARKER
    """

    for base in type_.mro():
        if base is AbstractPyProxyBase:
            continue
        res = base.__dict__.get(name, _MARKER)
        if res is not _MARKER:
            return res
    return _MARKER


def _get_wrapped(self):
    """
    Helper method to access the wrapped object.
    """
    return super(AbstractPyProxyBase, self).__getattribute__('_wrapped')


class _EmptyInterfaceDescriptor:
    """A descriptor for the attributes used on the class by the
    Python implementation of `zope.interface`.

    When wrapping builtin types, these descriptors prevent the objects
    we find in the AbstractPyProxyBase from being used.
    """

    def __get__(self, inst, klass):
        raise AttributeError()

    def __set__(self, inst, value):
        raise TypeError()

    def __delete__(self, inst):
        pass

    def __iter__(self):
        return self

    def __next__(self):
        raise StopIteration()
    next = __next__


class _ProxyMetaclass(type):
    # The metaclass is applied after the class definition
    # for Py2/Py3 compatibility.
    __implemented__ = _EmptyInterfaceDescriptor()


class AbstractPyProxyBase:
    """
    A reference implementation that cannot be instantiated. Most users
    will want to use :class:`PyProxyBase`.

    This type is intended to be used in multiple-inheritance
    scenarios, where another super class already has defined
    ``__slots__``. In order to subclass both that class and this
    class, you must include the ``_wrapped`` value in your own
    ``__slots__`` definition (or else you will get the infamous
    TypeError: "multiple bases have instance lay-out conflicts")
    """
    __slots__ = ()

    def __new__(cls, value=None):
        # Some subclasses (zope.security.proxy) fail to pass the object
        inst = super(AbstractPyProxyBase, cls).__new__(cls)
        inst._wrapped = value
        return inst

    def __init__(self, obj):
        self._wrapped = obj

    def __call__(self, *args, **kw):
        return self._wrapped(*args, **kw)

    def __repr__(self):
        return repr(self._wrapped)

    def __str__(self):
        return str(self._wrapped)

    def __reduce__(self):  # pragma: no cover  (__reduce_ex__ prevents normal)
        raise pickle.PicklingError

    def __reduce_ex__(self, proto):
        raise pickle.PicklingError

    # Rich comparison protocol
    def __lt__(self, other):
        return self._wrapped < other

    def __le__(self, other):
        return self._wrapped <= other

    def __eq__(self, other):
        return self._wrapped == other

    def __ne__(self, other):
        return self._wrapped != other

    def __gt__(self, other):
        return self._wrapped > other

    def __ge__(self, other):
        return self._wrapped >= other

    def __nonzero__(self):
        return bool(self._wrapped)
    __bool__ = __nonzero__  # Python3 compat

    def __hash__(self):
        return hash(self._wrapped)

    # Attribute protocol
    def __getattribute__(self, name):
        # Try to avoid accessing the _wrapped value until we need to.
        # We don't know how subclasses may be storing it
        # (e.g., persistent subclasses)
        if name == '_wrapped':
            return _get_wrapped(self)

        if name in ('__class__', '__module__'):
            # __class__ and __module__ are special cased in the C
            # implementation, because we will always find them on the
            # type of this object if we are being subclassed
            return getattr(_get_wrapped(self), name)

        if name in ('__reduce__', '__reduce_ex__'):
            # These things we specifically override and no one
            # can stop us, not even a subclass
            return object.__getattribute__(self, name)

        # First, look for descriptors in this object's type
        type_self = type(self)
        descriptor = _WrapperType_Lookup(type_self, name)
        if descriptor is _MARKER:
            # Nothing in the class, go straight to the wrapped object
            return getattr(_get_wrapped(self), name)

        if hasattr(descriptor, '__get__'):
            if not hasattr(descriptor, '__set__'):
                # Non-data-descriptor: call through to the wrapped object
                # to see if it's there
                try:
                    return getattr(_get_wrapped(self), name)
                except AttributeError:
                    pass
            # Data-descriptor on this type. Call it
            return descriptor.__get__(self, type_self)
        return descriptor

    def __getattr__(self, name):
        return getattr(self._wrapped, name)

    def __setattr__(self, name, value):
        if name == '_wrapped':
            return super(AbstractPyProxyBase, self).__setattr__(name, value)

        # First, look for descriptors in this object's type
        type_self = type(self)
        descriptor = _WrapperType_Lookup(type_self, name)
        if descriptor is _MARKER or not hasattr(descriptor, '__set__'):
            # Nothing in the class that's a descriptor,
            # go straight to the wrapped object
            return setattr(self._wrapped, name, value)

        return object.__setattr__(self, name, value)

    def __delattr__(self, name):
        if name == '_wrapped':
            raise AttributeError()
        delattr(self._wrapped, name)

    # Container protocols

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

    def __getslice__(self, start, stop):
        try:
            getslice = type(self._wrapped).__getslice__
        except AttributeError:
            return self.__getitem__(slice(start, stop))
        return getslice(self._wrapped, start, stop)

    def __getitem__(self, key):
        return self._wrapped[key]

    def __setslice__(self, start, stop, value):
        try:
            setslice = type(self._wrapped).__setslice__
        except AttributeError:
            return self.__setitem__(slice(start, stop), value)
        return setslice(self._wrapped, start, stop, value)

    def __setitem__(self, key, value):
        self._wrapped[key] = value

    def __delitem__(self, key):
        del self._wrapped[key]

    def __iter__(self):
        # This handles a custom __iter__ and generator support at the same
        # time.
        return iter(self._wrapped)

    def next(self):
        # Called when we wrap an iterator itself.
        return next(self._wrapped)

    def __next__(self):
        return self._wrapped.__next__()

    # Python 2.7 won't let the C wrapper support __reversed__
    # Uncomment this when the supported Python versions do
    # def __reversed__(self):
    #    return reversed(self._wrapped)

    def __contains__(self, item):
        return item in self._wrapped

    # Numeric protocol:  unary operators
    def __neg__(self):
        return -self._wrapped

    def __pos__(self):
        return +self._wrapped

    def __abs__(self):
        return abs(self._wrapped)

    def __invert__(self):
        return ~self._wrapped

    # Numeric protocol:  unary conversions
    def __complex__(self):
        return complex(self._wrapped)

    def __int__(self):
        return int(self._wrapped)

    # BBB Should go away after zope.security is fixed
    # see https://github.com/zopefoundation/zope.security/issues/92
    def __long__(self):
        return long(self._wrapped)  # noqa: F821 undefined name

    def __float__(self):
        return float(self._wrapped)

    def __oct__(self):
        return oct(self._wrapped)

    def __hex__(self):
        return hex(self._wrapped)

    def __index__(self):
        return operator.index(self._wrapped)

    # Numeric protocol:  binary arithmetic operators
    def __add__(self, other):
        return self._wrapped + other

    def __sub__(self, other):
        return self._wrapped - other

    def __mul__(self, other):
        return self._wrapped * other

    def __floordiv__(self, other):
        return self._wrapped // other

    def __truediv__(self, other):  # pragma: no cover
        # Only one of __truediv__ and __div__ is meaningful at any one time.
        return self._wrapped / other

    def __div__(self, other):  # pragma: no cover
        # Only one of __truediv__ and __div__ is meaningful at any one time.
        return self._wrapped / other

    def __mod__(self, other):
        return self._wrapped % other

    def __divmod__(self, other):
        return divmod(self._wrapped, other)

    def __pow__(self, other, modulus=None):
        if modulus is None:
            return pow(self._wrapped, other)
        return pow(self._wrapped, other, modulus)

    def __radd__(self, other):
        return other + self._wrapped

    def __rsub__(self, other):
        return other - self._wrapped

    def __rmul__(self, other):
        return other * self._wrapped

    def __rfloordiv__(self, other):
        return other // self._wrapped

    def __rtruediv__(self, other):  # pragma: no cover
        # Only one of __rtruediv__ and __rdiv__ is meaningful at any one time.
        return other / self._wrapped

    def __rdiv__(self, other):  # pragma: no cover
        # Only one of __rtruediv__ and __rdiv__ is meaningful at any one time.
        return other / self._wrapped

    def __rmod__(self, other):
        return other % self._wrapped

    def __rdivmod__(self, other):
        return divmod(other, self._wrapped)

    def __rpow__(self, other, modulus=None):
        if modulus is None:
            return pow(other, self._wrapped)
        # We can't actually get here, because we can't lie about our type()
        return pow(other, self._wrapped, modulus)  # pragma: no cover

    # Numeric protocol:  binary bitwise operators
    def __lshift__(self, other):
        return self._wrapped << other

    def __rshift__(self, other):
        return self._wrapped >> other

    def __and__(self, other):
        return self._wrapped & other

    def __xor__(self, other):
        return self._wrapped ^ other

    def __or__(self, other):
        return self._wrapped | other

    def __rlshift__(self, other):
        return other << self._wrapped

    def __rrshift__(self, other):
        return other >> self._wrapped

    def __rand__(self, other):
        return other & self._wrapped

    def __rxor__(self, other):
        return other ^ self._wrapped

    def __ror__(self, other):
        return other | self._wrapped

    # Numeric protocol:  binary in-place operators
    def __iadd__(self, other):
        self._wrapped += other
        return self

    def __isub__(self, other):
        self._wrapped -= other
        return self

    def __imul__(self, other):
        self._wrapped *= other
        return self

    def __idiv__(self, other):  # pragma: no cover
        # Only one of __itruediv__ and __idiv__ is meaningful at any one time.
        self._wrapped /= other
        return self

    def __itruediv__(self, other):  # pragma: no cover
        # Only one of __itruediv__ and __idiv__ is meaningful at any one time.
        self._wrapped /= other
        return self

    def __ifloordiv__(self, other):
        self._wrapped //= other
        return self

    def __imod__(self, other):
        self._wrapped %= other
        return self

    def __ilshift__(self, other):
        self._wrapped <<= other
        return self

    def __irshift__(self, other):
        self._wrapped >>= other
        return self

    def __iand__(self, other):
        self._wrapped &= other
        return self

    def __ixor__(self, other):
        self._wrapped ^= other
        return self

    def __ior__(self, other):
        self._wrapped |= other
        return self

    def __ipow__(self, other, modulus=None):
        if modulus is None:
            self._wrapped **= other
        else:  # pragma: no cover
            # There is no syntax which triggers in-place pow w/ modulus
            self._wrapped = pow(self._wrapped, other, modulus)
        return self


AbstractPyProxyBase = _ProxyMetaclass('AbstractPyProxyBase', (),
                                      dict(AbstractPyProxyBase.__dict__))


class PyProxyBase(AbstractPyProxyBase):
    """Reference implementation.
    """
    __slots__ = ('_wrapped', )


def py_getProxiedObject(obj):
    if isinstance(obj, PyProxyBase):
        return obj._wrapped
    return obj


def py_setProxiedObject(obj, new_value):
    if not isinstance(obj, PyProxyBase):
        raise TypeError('Not a proxy')
    old, obj._wrapped = obj._wrapped, new_value
    return old


def py_isProxy(obj, klass=None):
    if klass is None:
        klass = PyProxyBase
    return isinstance(obj, klass)


def py_sameProxiedObjects(lhs, rhs):
    while isinstance(lhs, PyProxyBase):
        lhs = super(PyProxyBase, lhs).__getattribute__('_wrapped')
    while isinstance(rhs, PyProxyBase):
        rhs = super(PyProxyBase, rhs).__getattribute__('_wrapped')
    return lhs is rhs


def py_queryProxy(obj, klass=None, default=None):
    if klass is None:
        klass = PyProxyBase
    while obj is not None and not isinstance(obj, klass):
        obj = getattr(obj, '_wrapped', None)
    if obj is not None:
        return obj
    return default


def py_queryInnerProxy(obj, klass=None, default=None):
    if klass is None:
        klass = PyProxyBase
    found = []
    while obj is not None:
        if isinstance(obj, klass):
            found.append(obj)  # stack
        obj = getattr(obj, '_wrapped', None)
    if found:
        return found[-1]
    return default


def py_removeAllProxies(obj):
    while isinstance(obj, PyProxyBase):
        obj = super(PyProxyBase, obj).__getattribute__('_wrapped')
    return obj


_c_available = False
if 'PURE_PYTHON' not in os.environ:
    try:  # pragma: no cover
        from zope.proxy._zope_proxy_proxy import ProxyBase as _c_available
    except ImportError:
        pass


class PyNonOverridable:
    "Deprecated, only for BWC."

    def __init__(self, method_desc):  # pragma: no cover PyPy
        self.desc = method_desc


if _c_available:  # pragma: no cover
    # Python API:  not used in this module
    # API for proxy-using C extensions.
    from zope.proxy._zope_proxy_proxy import _CAPI  # noqa: F401 unused
    from zope.proxy._zope_proxy_proxy import ProxyBase
    from zope.proxy._zope_proxy_proxy import getProxiedObject
    from zope.proxy._zope_proxy_proxy import isProxy
    from zope.proxy._zope_proxy_proxy import queryInnerProxy
    from zope.proxy._zope_proxy_proxy import queryProxy
    from zope.proxy._zope_proxy_proxy import removeAllProxies
    from zope.proxy._zope_proxy_proxy import sameProxiedObjects
    from zope.proxy._zope_proxy_proxy import setProxiedObject

else:
    # no C extension available, fall back
    ProxyBase = PyProxyBase
    getProxiedObject = py_getProxiedObject
    setProxiedObject = py_setProxiedObject
    isProxy = py_isProxy
    sameProxiedObjects = py_sameProxiedObjects
    queryProxy = py_queryProxy
    queryInnerProxy = py_queryInnerProxy
    removeAllProxies = py_removeAllProxies


def non_overridable(func):
    return property(lambda self: func.__get__(self))

1	##############################################################################
2	#
3	# Copyright (c) 2003 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	"""More convenience functions for dealing with proxies.	6✔
15	"""
16	import operator	6✔
17	import os	6✔
18	import pickle	6✔
19
20	from zope.interface import moduleProvides	6✔
21
22	from zope.proxy.interfaces import IProxyIntrospection	6✔
23
24
25	moduleProvides(IProxyIntrospection)	6✔
26	__all__ = tuple(IProxyIntrospection)	6✔
27
28
29	def ProxyIterator(p):	6✔
30	yield p	6✔
31	while isProxy(p):	6✔
32	p = getProxiedObject(p)	6✔
33	yield p	6✔
34
35
36	_MARKER = object()	6✔
37
38
39	def _WrapperType_Lookup(type_, name):	6✔
40	"""
41	Looks up information in class dictionaries in MRO
42	order, ignoring the proxy type itself.
43
44	Returns the first found object, or _MARKER
45	"""
46
47	for base in type_.mro():	6✔
48	if base is AbstractPyProxyBase:	6✔
49	continue	6✔
50	res = base.__dict__.get(name, _MARKER)	6✔
51	if res is not _MARKER:	6✔
52	return res	6✔
53	return _MARKER	6✔
54
55
56	def _get_wrapped(self):	6✔
57	"""
58	Helper method to access the wrapped object.
59	"""
60	return super(AbstractPyProxyBase, self).__getattribute__('_wrapped')	6✔
61
62
63	class _EmptyInterfaceDescriptor:	6✔
64	"""A descriptor for the attributes used on the class by the
65	Python implementation of `zope.interface`.
66
67	When wrapping builtin types, these descriptors prevent the objects
68	we find in the AbstractPyProxyBase from being used.
69	"""
70
71	def __get__(self, inst, klass):	6✔
72	raise AttributeError()	6✔
73
74	def __set__(self, inst, value):	6✔
75	raise TypeError()	6✔
76
77	def __delete__(self, inst):	6✔
78	pass	6✔
79
80	def __iter__(self):	6✔
81	return self	6✔
82
83	def __next__(self):	6✔
84	raise StopIteration()	6✔
85	next = __next__	6✔
86
87
88	class _ProxyMetaclass(type):	6✔
89	# The metaclass is applied after the class definition
90	# for Py2/Py3 compatibility.
91	__implemented__ = _EmptyInterfaceDescriptor()	6✔
92
93
94	class AbstractPyProxyBase:	6✔
95	"""
96	A reference implementation that cannot be instantiated. Most users
97	will want to use :class:`PyProxyBase`.
98
99	This type is intended to be used in multiple-inheritance
100	scenarios, where another super class already has defined
101	``__slots__``. In order to subclass both that class and this
102	class, you must include the ``_wrapped`` value in your own
103	``__slots__`` definition (or else you will get the infamous
104	TypeError: "multiple bases have instance lay-out conflicts")
105	"""
106	__slots__ = ()	6✔
107
108	def __new__(cls, value=None):	6✔
109	# Some subclasses (zope.security.proxy) fail to pass the object
110	inst = super(AbstractPyProxyBase, cls).__new__(cls)	6✔
111	inst._wrapped = value	6✔
112	return inst	6✔
113
114	def __init__(self, obj):	6✔
115	self._wrapped = obj	6✔
116
117	def __call__(self, args, *kw):	6✔
118	return self._wrapped(args, *kw)	6✔
119
120	def __repr__(self):	6✔
121	return repr(self._wrapped)	6✔
122
123	def __str__(self):	6✔
124	return str(self._wrapped)	6✔
125
126	def __reduce__(self): # pragma: no cover (__reduce_ex__ prevents normal)
127	raise pickle.PicklingError
128
129	def __reduce_ex__(self, proto):	6✔
UNCOV 130	raise pickle.PicklingError	×
131
132	# Rich comparison protocol
133	def __lt__(self, other):	6✔
134	return self._wrapped < other	6✔
135
136	def __le__(self, other):	6✔
137	return self._wrapped <= other	6✔
138
139	def __eq__(self, other):	6✔
140	return self._wrapped == other	6✔
141
142	def __ne__(self, other):	6✔
143	return self._wrapped != other	6✔
144
145	def __gt__(self, other):	6✔
146	return self._wrapped > other	6✔
147
148	def __ge__(self, other):	6✔
149	return self._wrapped >= other	6✔
150
151	def __nonzero__(self):	6✔
152	return bool(self._wrapped)	6✔
153	__bool__ = __nonzero__ # Python3 compat	6✔
154
155	def __hash__(self):	6✔
156	return hash(self._wrapped)	6✔
157
158	# Attribute protocol
159	def __getattribute__(self, name):	6✔
160	# Try to avoid accessing the _wrapped value until we need to.
161	# We don't know how subclasses may be storing it
162	# (e.g., persistent subclasses)
163	if name == '_wrapped':	6✔
164	return _get_wrapped(self)	6✔
165
166	if name in ('__class__', '__module__'):	6✔
167	# __class__ and __module__ are special cased in the C
168	# implementation, because we will always find them on the
169	# type of this object if we are being subclassed
170	return getattr(_get_wrapped(self), name)	6✔
171
172	if name in ('__reduce__', '__reduce_ex__'):	6!
173	# These things we specifically override and no one
174	# can stop us, not even a subclass
UNCOV 175	return object.__getattribute__(self, name)	×
176
177	# First, look for descriptors in this object's type
178	type_self = type(self)	6✔
179	descriptor = _WrapperType_Lookup(type_self, name)	6✔
180	if descriptor is _MARKER:	6✔
181	# Nothing in the class, go straight to the wrapped object
182	return getattr(_get_wrapped(self), name)	6✔
183
184	if hasattr(descriptor, '__get__'):	6✔
185	if not hasattr(descriptor, '__set__'):	6✔
186	# Non-data-descriptor: call through to the wrapped object
187	# to see if it's there
188	try:	6✔
189	return getattr(_get_wrapped(self), name)	6✔
190	except AttributeError:	6✔
191	pass	6✔
192	# Data-descriptor on this type. Call it
193	return descriptor.__get__(self, type_self)	6✔
194	return descriptor	6✔
195
196	def __getattr__(self, name):	6✔
197	return getattr(self._wrapped, name)	6✔
198
199	def __setattr__(self, name, value):	6✔
200	if name == '_wrapped':	6✔
201	return super(AbstractPyProxyBase, self).__setattr__(name, value)	6✔
202
203	# First, look for descriptors in this object's type
204	type_self = type(self)	6✔
205	descriptor = _WrapperType_Lookup(type_self, name)	6✔
206	if descriptor is _MARKER or not hasattr(descriptor, '__set__'):	6✔
207	# Nothing in the class that's a descriptor,
208	# go straight to the wrapped object
209	return setattr(self._wrapped, name, value)	6✔
210
211	return object.__setattr__(self, name, value)	6✔
212
213	def __delattr__(self, name):	6✔
214	if name == '_wrapped':	6✔
215	raise AttributeError()	6✔
216	delattr(self._wrapped, name)	6✔
217
218	# Container protocols
219
220	def __len__(self):	6✔
221	return len(self._wrapped)	6✔
222
223	def __getslice__(self, start, stop):	6✔
224	try:	×
225	getslice = type(self._wrapped).__getslice__	×
UNCOV 226	except AttributeError:	×
UNCOV 227	return self.__getitem__(slice(start, stop))	×
UNCOV 228	return getslice(self._wrapped, start, stop)	×
229
230	def __getitem__(self, key):	6✔
231	return self._wrapped[key]	6✔
232
233	def __setslice__(self, start, stop, value):	6✔
234	try:	×
235	setslice = type(self._wrapped).__setslice__	×
UNCOV 236	except AttributeError:	×
UNCOV 237	return self.__setitem__(slice(start, stop), value)	×
UNCOV 238	return setslice(self._wrapped, start, stop, value)	×
239
240	def __setitem__(self, key, value):	6✔
241	self._wrapped[key] = value	6✔
242
243	def __delitem__(self, key):	6✔
244	del self._wrapped[key]	6✔
245
246	def __iter__(self):	6✔
247	# This handles a custom __iter__ and generator support at the same
248	# time.
249	return iter(self._wrapped)	6✔
250
251	def next(self):	6✔
252	# Called when we wrap an iterator itself.
NEW 253	return next(self._wrapped)	×
254
255	def __next__(self):	6✔
256	return self._wrapped.__next__()	6✔
257
258	# Python 2.7 won't let the C wrapper support __reversed__
259	# Uncomment this when the supported Python versions do
260	# def __reversed__(self):
261	# return reversed(self._wrapped)
262
263	def __contains__(self, item):	6✔
264	return item in self._wrapped	6✔
265
266	# Numeric protocol: unary operators
267	def __neg__(self):	6✔
268	return -self._wrapped	6✔
269
270	def __pos__(self):	6✔
271	return +self._wrapped	6✔
272
273	def __abs__(self):	6✔
274	return abs(self._wrapped)	6✔
275
276	def __invert__(self):	6✔
277	return ~self._wrapped	6✔
278
279	# Numeric protocol: unary conversions
280	def __complex__(self):	6✔
281	return complex(self._wrapped)	6✔
282
283	def __int__(self):	6✔
284	return int(self._wrapped)	6✔
285
286	# BBB Should go away after zope.security is fixed
287	# see https://github.com/zopefoundation/zope.security/issues/92
288	def __long__(self):	6✔
UNCOV 289	return long(self._wrapped) # noqa: F821 undefined name	×
290
291	def __float__(self):	6✔
292	return float(self._wrapped)	6✔
293
294	def __oct__(self):	6✔
295	return oct(self._wrapped)	×
296
297	def __hex__(self):	6✔
298	return hex(self._wrapped)	×
299
300	def __index__(self):	6✔
301	return operator.index(self._wrapped)	6✔
302
303	# Numeric protocol: binary arithmetic operators
304	def __add__(self, other):	6✔
305	return self._wrapped + other	6✔
306
307	def __sub__(self, other):	6✔
308	return self._wrapped - other	6✔
309
310	def __mul__(self, other):	6✔
311	return self._wrapped * other	6✔
312
313	def __floordiv__(self, other):	6✔
314	return self._wrapped // other	6✔
315
316	def __truediv__(self, other): # pragma: no cover
317	# Only one of __truediv__ and __div__ is meaningful at any one time.
318	return self._wrapped / other
319
320	def __div__(self, other): # pragma: no cover
321	# Only one of __truediv__ and __div__ is meaningful at any one time.
322	return self._wrapped / other
323
324	def __mod__(self, other):	6✔
325	return self._wrapped % other	6✔
326
327	def __divmod__(self, other):	6✔
328	return divmod(self._wrapped, other)	6✔
329
330	def __pow__(self, other, modulus=None):	6✔
331	if modulus is None:	6✔
332	return pow(self._wrapped, other)	6✔
333	return pow(self._wrapped, other, modulus)	6✔
334
335	def __radd__(self, other):	6✔
336	return other + self._wrapped	6✔
337
338	def __rsub__(self, other):	6✔
339	return other - self._wrapped	6✔
340
341	def __rmul__(self, other):	6✔
342	return other * self._wrapped	6✔
343
344	def __rfloordiv__(self, other):	6✔
345	return other // self._wrapped	6✔
346
347	def __rtruediv__(self, other): # pragma: no cover
348	# Only one of __rtruediv__ and __rdiv__ is meaningful at any one time.
349	return other / self._wrapped
350
351	def __rdiv__(self, other): # pragma: no cover
352	# Only one of __rtruediv__ and __rdiv__ is meaningful at any one time.
353	return other / self._wrapped
354
355	def __rmod__(self, other):	6✔
356	return other % self._wrapped	6✔
357
358	def __rdivmod__(self, other):	6✔
359	return divmod(other, self._wrapped)	6✔
360
361	def __rpow__(self, other, modulus=None):	6✔
362	if modulus is None:	6✔
363	return pow(other, self._wrapped)	6✔
364	# We can't actually get here, because we can't lie about our type()
365	return pow(other, self._wrapped, modulus) # pragma: no cover
366
367	# Numeric protocol: binary bitwise operators
368	def __lshift__(self, other):	6✔
369	return self._wrapped << other	6✔
370
371	def __rshift__(self, other):	6✔
372	return self._wrapped >> other	6✔
373
374	def __and__(self, other):	6✔
375	return self._wrapped & other	6✔
376
377	def __xor__(self, other):	6✔
378	return self._wrapped ^ other	6✔
379
380	def __or__(self, other):	6✔
381	return self._wrapped \| other	6✔
382
383	def __rlshift__(self, other):	6✔
384	return other << self._wrapped	6✔
385
386	def __rrshift__(self, other):	6✔
387	return other >> self._wrapped	6✔
388
389	def __rand__(self, other):	6✔
390	return other & self._wrapped	6✔
391
392	def __rxor__(self, other):	6✔
393	return other ^ self._wrapped	6✔
394
395	def __ror__(self, other):	6✔
396	return other \| self._wrapped	6✔
397
398	# Numeric protocol: binary in-place operators
399	def __iadd__(self, other):	6✔
400	self._wrapped += other	6✔
401	return self	6✔
402
403	def __isub__(self, other):	6✔
404	self._wrapped -= other	6✔
405	return self	6✔
406
407	def __imul__(self, other):	6✔
408	self._wrapped *= other	6✔
409	return self	6✔
410
411	def __idiv__(self, other): # pragma: no cover
412	# Only one of __itruediv__ and __idiv__ is meaningful at any one time.
413	self._wrapped /= other
414	return self
415
416	def __itruediv__(self, other): # pragma: no cover
417	# Only one of __itruediv__ and __idiv__ is meaningful at any one time.
418	self._wrapped /= other
419	return self
420
421	def __ifloordiv__(self, other):	6✔
422	self._wrapped //= other	6✔
423	return self	6✔
424
425	def __imod__(self, other):	6✔
426	self._wrapped %= other	6✔
427	return self	6✔
428
429	def __ilshift__(self, other):	6✔
430	self._wrapped <<= other	6✔
431	return self	6✔
432
433	def __irshift__(self, other):	6✔
434	self._wrapped >>= other	6✔
435	return self	6✔
436
437	def __iand__(self, other):	6✔
438	self._wrapped &= other	6✔
439	return self	6✔
440
441	def __ixor__(self, other):	6✔
442	self._wrapped ^= other	6✔
443	return self	6✔
444
445	def __ior__(self, other):	6✔
446	self._wrapped \|= other	6✔
447	return self	6✔
448
449	def __ipow__(self, other, modulus=None):	6✔
450	if modulus is None:	6✔
451	self._wrapped **= other	6✔
452	else: # pragma: no cover
453	# There is no syntax which triggers in-place pow w/ modulus
454	self._wrapped = pow(self._wrapped, other, modulus)
455	return self	6✔
456
457
458	AbstractPyProxyBase = _ProxyMetaclass('AbstractPyProxyBase', (),	6✔
459	dict(AbstractPyProxyBase.__dict__))
460
461
462	class PyProxyBase(AbstractPyProxyBase):	6✔
463	"""Reference implementation.
464	"""
465	__slots__ = ('_wrapped', )	6✔
466
467
468	def py_getProxiedObject(obj):	6✔
469	if isinstance(obj, PyProxyBase):	6✔
470	return obj._wrapped	6✔
471	return obj	6✔
472
473
474	def py_setProxiedObject(obj, new_value):	6✔
475	if not isinstance(obj, PyProxyBase):	6✔
476	raise TypeError('Not a proxy')	6✔
477	old, obj._wrapped = obj._wrapped, new_value	6✔
478	return old	6✔
479
480
481	def py_isProxy(obj, klass=None):	6✔
482	if klass is None:	6✔
483	klass = PyProxyBase	6✔
484	return isinstance(obj, klass)	6✔
485
486
487	def py_sameProxiedObjects(lhs, rhs):	6✔
488	while isinstance(lhs, PyProxyBase):	6✔
489	lhs = super(PyProxyBase, lhs).__getattribute__('_wrapped')	6✔
490	while isinstance(rhs, PyProxyBase):	6✔
491	rhs = super(PyProxyBase, rhs).__getattribute__('_wrapped')	6✔
492	return lhs is rhs	6✔
493
494
495	def py_queryProxy(obj, klass=None, default=None):	6✔
496	if klass is None:	6✔
497	klass = PyProxyBase	6✔
498	while obj is not None and not isinstance(obj, klass):	6✔
499	obj = getattr(obj, '_wrapped', None)	6✔
500	if obj is not None:	6✔
501	return obj	6✔
502	return default	6✔
503
504
505	def py_queryInnerProxy(obj, klass=None, default=None):	6✔
506	if klass is None:	6✔
507	klass = PyProxyBase	6✔
508	found = []	6✔
509	while obj is not None:	6✔
510	if isinstance(obj, klass):	6✔
511	found.append(obj) # stack	6✔
512	obj = getattr(obj, '_wrapped', None)	6✔
513	if found:	6✔
514	return found[-1]	6✔
515	return default	6✔
516
517
518	def py_removeAllProxies(obj):	6✔
519	while isinstance(obj, PyProxyBase):	6✔
520	obj = super(PyProxyBase, obj).__getattribute__('_wrapped')	6✔
521	return obj	6✔
522
523
524	_c_available = False	6✔
525	if 'PURE_PYTHON' not in os.environ:	6✔
526	try: # pragma: no cover
527	from zope.proxy._zope_proxy_proxy import ProxyBase as _c_available
528	except ImportError:
529	pass
530
531
532	class PyNonOverridable:	6✔
533	"Deprecated, only for BWC."
534
535	def __init__(self, method_desc): # pragma: no cover PyPy
536	self.desc = method_desc
537
538
539	if _c_available: # pragma: no cover
540	# Python API: not used in this module
541	# API for proxy-using C extensions.
542	from zope.proxy._zope_proxy_proxy import _CAPI # noqa: F401 unused
543	from zope.proxy._zope_proxy_proxy import ProxyBase
544	from zope.proxy._zope_proxy_proxy import getProxiedObject
545	from zope.proxy._zope_proxy_proxy import isProxy
546	from zope.proxy._zope_proxy_proxy import queryInnerProxy
547	from zope.proxy._zope_proxy_proxy import queryProxy
548	from zope.proxy._zope_proxy_proxy import removeAllProxies
549	from zope.proxy._zope_proxy_proxy import sameProxiedObjects
550	from zope.proxy._zope_proxy_proxy import setProxiedObject
551
552	else:
553	# no C extension available, fall back
554	ProxyBase = PyProxyBase	6✔
555	getProxiedObject = py_getProxiedObject	6✔
556	setProxiedObject = py_setProxiedObject	6✔
557	isProxy = py_isProxy	6✔
558	sameProxiedObjects = py_sameProxiedObjects	6✔
559	queryProxy = py_queryProxy	6✔
560	queryInnerProxy = py_queryInnerProxy	6✔
561	removeAllProxies = py_removeAllProxies	6✔
562
563
564	def non_overridable(func):	6✔
565	return property(lambda self: func.__get__(self))	6✔

zopefoundation / zope.proxy / 3923311326

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