Merge lp:~zyga/checkbox/padme-switch into lp:checkbox

[Zygmunt Krynicki]

[Sylvain Pineau (sylvain-pineau)]

the devendorization continues, +1

review: Approve

=== modified file 'plainbox/plainbox/impl/censoREd.py'
--- plainbox/plainbox/impl/censoREd.py	2015-07-13 09:57:16 +0000
+++ plainbox/plainbox/impl/censoREd.py	2015-08-31 14:17:15 +0000
@@ -56,8 +56,7 @@
 The last resort, aka, the proxy approach. Let's use a bit of magic to work
 around the problem. This way we won't have to subclass or override anything.
 """
-from plainbox.impl.proxy import proxy
-from plainbox.impl.proxy import unproxied
+from padme import proxy
 
 
 __all__ = ["PatternProxy"]
@@ -86,6 +85,6 @@
 
     **Yes** (gets another drink).
     """
-    @unproxied
+    @proxy.direct
     def __repr__(self):
         return "re.compile({!r})".format(self.pattern)

=== removed file 'plainbox/plainbox/impl/proxy.py'
--- plainbox/plainbox/impl/proxy.py	2015-01-29 01:57:26 +0000
+++ plainbox/plainbox/impl/proxy.py	1970-01-01 00:00:00 +0000
@@ -1,401 +0,0 @@
-# This file is part of Checkbox.
-#
-# Copyright 2012-2015 Canonical Ltd.
-# Written by:
-#   Zygmunt Krynicki <[e-mail]>
-#
-# Checkbox is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License version 3,
-# as published by the Free Software Foundation.
-#
-# Checkbox is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
-"""
-:mod:`plainbox.impl.proxy ` -- mostly transparent proxy
-=======================================================
-
-.. note::
-    There are a number of classes and meta-classes but the only public
-    interface is the :class:`proxy` class. See below for examples.
-"""
-import logging
-import itertools
-
-_logger = logging.getLogger("plainbox.proxy")
-
-
-__all__ = ['proxy']
-
-
-class proxy_meta(type):
-    """
-    Meta-class for all proxy types
-
-    This meta-class is responsible for gathering the __unproxied__ attribute on
-    each created class. The attribute is a frosenset of names that will not be
-    forwarded to the ``proxxie`` but instead will be looked up on the proxy
-    itself.
-    """
-
-    def __new__(mcls, name, bases, ns):
-        _logger.debug(
-            "__new__ on proxy_meta with name: %r, bases: %r", name, bases)
-        unproxied_set = set()
-        for base in bases:
-            if hasattr(base, '__unproxied__'):
-                unproxied_set.update(base.__unproxied__)
-        for ns_attr, ns_value in ns.items():
-            if getattr(ns_value, 'unproxied', False):
-                unproxied_set.add(ns_attr)
-        if unproxied_set:
-            _logger.debug(
-                "proxy type %r will pass-thru %r", name, unproxied_set)
-        ns['__unproxied__'] = frozenset(unproxied_set)
-        return super().__new__(mcls, name, bases, ns)
-
-
-cnt = itertools.count()
-
-
-def make_boundproxy_meta(proxiee):
-    """
-    Make a new bound proxy meta-class for the specified object
-
-    :param proxiee:
-        The object that will be proxied
-    :returns:
-        A new meta-class that lexically wraps ``proxiee`` and subclasses
-        :class:`proxy_meta`.
-    """
-
-    class boundproxy_meta(proxy_meta):
-        """
-        Meta-class for all bound proxies.
-
-        This meta-class is responsible for generating an unique name for each
-        created class and setting the setting the ``__proxiee__`` attribute to
-        the proxiee object itself.
-
-        In addition, it implements two methods that participate in instance and
-        class checks: ``__instancecheck__`` and ``__subclasscheck__``.
-        """
-
-        def __new__(mcls, name, bases, ns):
-            name = 'boundproxy[{!r}]'.format(next(cnt))
-            _logger.debug(
-                "__new__ on boundproxy_meta with name %r and bases %r",
-                name, bases)
-            ns['__proxiee__'] = proxiee
-            return super().__new__(mcls, name, bases, ns)
-
-        def __instancecheck__(mcls, instance):
-            # NOTE: this is never called in practice since
-            # proxy(obj).__class__ is really obj.__class__.
-            _logger.debug("__instancecheck__ %r on %r", instance, proxiee)
-            return isinstance(instance, type(proxiee))
-
-        def __subclasscheck__(mcls, subclass):
-            # This is still called though since type(proxy(obj)) is
-            # something else
-            _logger.debug("__subclasscheck__ %r on %r", subclass, proxiee)
-            return issubclass(type(proxiee), subclass)
-
-    return boundproxy_meta
-
-
-class proxy_base:
-    """
-    Base class for all proxies.
-
-    This class implements the bulk of the proxy work by having a lot of dunder
-    methods that delegate their work to a ``proxiee`` object. The ``proxiee``
-    object must be available as the ``__proxiee__`` attribute on a class
-    deriving from ``base_proxy``. Apart from ``__proxiee__`, the
-    ``__unproxied__`` attribute, which should be a frozenset, must also be
-    present in all derived classes.
-
-    In practice, the two special attributes are injected via
-    ``boundproxy_meta`` created by :func:`make_boundproxy_meta()`. This class
-    is also used as a base class for the tricky :class:`proxy` below.
-
-    NOTE: Look at ``pydoc3 SPECIALMETHODS`` section titled ``Special method
-    lookup`` for a rationale of why we have all those dunder methods while
-    still having __getattribute__()
-    """
-    # NOTE: the order of methods below matches that of ``pydoc3
-    # SPECIALMETHODS``. The "N/A to instances" text means that it makes no
-    # sense to add proxy support to the specified method because that method
-    # makes no sense on instances. Proxy is designed to intercept access to
-    # *objects*, not construction of such objects in the first place.
-
-    # N/A to instances: __new__
-
-    # N/A to instances: __init__
-
-    def __del__(self):
-        """
-        NOTE: this method is handled specially since it must be called
-        after an object becomes unreachable. As long as the proxy object
-        itself exits, it holds a strong reference to the original object.
-        """
-
-    def __repr__(self):
-        proxiee = type(self).__proxiee__
-        _logger.debug("__repr__ on proxiee (%r)", proxiee)
-        return repr(proxiee)
-
-    def __str__(self):
-        proxiee = type(self).__proxiee__
-        _logger.debug("__str__ on proxiee (%r)", proxiee)
-        return str(proxiee)
-
-    def __bytes__(self):
-        proxiee = type(self).__proxiee__
-        _logger.debug("__bytes__ on proxiee (%r)", proxiee)
-        return bytes(proxiee)
-
-    def __format__(self, format_spec):
-        proxiee = type(self).__proxiee__
-        _logger.debug("__format__ on proxiee (%r)", proxiee)
-        return format(proxiee, format_spec)
-
-    def __lt__(self, other):
-        proxiee = type(self).__proxiee__
-        _logger.debug("__lt__ on proxiee (%r)", proxiee)
-        return proxiee < other
-
-    def __le__(self, other):
-        proxiee = type(self).__proxiee__
-        _logger.debug("__le__ on proxiee (%r)", proxiee)
-        return proxiee <= other
-
-    def __eq__(self, other):
-        proxiee = type(self).__proxiee__
-        _logger.debug("__eq__ on proxiee (%r)", proxiee)
-        return proxiee == other
-
-    def __ne__(self, other):
-        proxiee = type(self).__proxiee__
-        _logger.debug("__ne__ on proxiee (%r)", proxiee)
-        return proxiee != other
-
-    def __gt__(self, other):
-        proxiee = type(self).__proxiee__
-        _logger.debug("__gt__ on proxiee (%r)", proxiee)
-        return proxiee > other
-
-    def __ge__(self, other):
-        proxiee = type(self).__proxiee__
-        _logger.debug("__ge__ on proxiee (%r)", proxiee)
-        return proxiee >= other
-
-    def __hash__(self):
-        proxiee = type(self).__proxiee__
-        _logger.debug("__hash__ on proxiee (%r)", proxiee)
-        return hash(proxiee)
-
-    def __bool__(self):
-        proxiee = type(self).__proxiee__
-        _logger.debug("__bool__ on proxiee (%r)", proxiee)
-        return bool(proxiee)
-
-    def __getattr__(self, name):
-        proxiee = type(self).__proxiee__
-        _logger.debug("__getattr__ %r on proxiee (%r)", name, proxiee)
-        return getattr(proxiee, name)
-
-    def __getattribute__(self, name):
-        cls = type(self)
-        if name not in cls.__unproxied__:
-            proxiee = cls.__proxiee__
-            _logger.debug("__getattribute__ %r on proxiee (%r)", name, proxiee)
-            return getattr(proxiee, name)
-        else:
-            _logger.debug("__getattribute__ %r on proxy itself", name)
-            return object.__getattribute__(self, name)
-
-    def __setattr__(self, attr, value):
-        proxiee = type(self).__proxiee__
-        _logger.debug("__setattr__ %r on proxiee (%r)", attr, proxiee)
-        setattr(proxiee, attr, value)
-
-    def __delattr__(self, attr):
-        proxiee = type(self).__proxiee__
-        _logger.debug("__delattr__ %r on proxiee (%r)", attr, proxiee)
-        delattr(proxiee, attr)
-
-    def __dir__(self):
-        proxiee = type(self).__proxiee__
-        _logger.debug("__dir__ on proxiee (%r)", proxiee)
-        return dir(proxiee)
-
-    def __get__(self, instance, owner):
-        proxiee = type(self).__proxiee__
-        _logger.debug("__get__ on proxiee (%r)", proxiee)
-        return proxiee.__get__(instance, owner)
-
-    def __set__(self, instance, value):
-        proxiee = type(self).__proxiee__
-        _logger.debug("__set__ on proxiee (%r)", proxiee)
-        proxiee.__set__(instance, value)
-
-    def __delete__(self, instance):
-        proxiee = type(self).__proxiee__
-        _logger.debug("__delete__ on proxiee (%r)", proxiee)
-        proxiee.__delete__(instance)
-
-    def __call__(self, *args, **kwargs):
-        proxiee = type(self).__proxiee__
-        _logger.debug("call on proxiee (%r)", proxiee)
-        return proxiee(*args, **kwargs)
-
-    def __len__(self):
-        proxiee = type(self).__proxiee__
-        _logger.debug("__len__ on proxiee (%r)", proxiee)
-        return len(proxiee)
-
-    def __length_hint__(self):
-        proxiee = type(self).__proxiee__
-        _logger.debug("__length_hint__ on proxiee (%r)", proxiee)
-        return proxiee.__length_hint__()
-
-    def __getitem__(self, item):
-        proxiee = type(self).__proxiee__
-        _logger.debug("__getitem__ on proxiee (%r)", proxiee)
-        return proxiee[item]
-
-    def __setitem__(self, item, value):
-        proxiee = type(self).__proxiee__
-        _logger.debug("__setitem__ on proxiee (%r)", proxiee)
-        proxiee[item] = value
-
-    def __delitem__(self, item):
-        proxiee = type(self).__proxiee__
-        _logger.debug("__delitem__ on proxiee (%r)", proxiee)
-        del proxiee[item]
-
-    def __iter__(self):
-        proxiee = type(self).__proxiee__
-        _logger.debug("__iter__ on proxiee (%r)", proxiee)
-        return iter(proxiee)
-
-    def __reversed__(self):
-        proxiee = type(self).__proxiee__
-        _logger.debug("__reversed__ on proxiee (%r)", proxiee)
-        return reversed(proxiee)
-
-    def __contains__(self, item):
-        proxiee = type(self).__proxiee__
-        _logger.debug("__contains__ on proxiee (%r)", proxiee)
-        return item in proxiee
-
-    # TODO: all numeric methods
-
-    def __enter__(self):
-        proxiee = type(self).__proxiee__
-        _logger.debug("__enter__ on proxiee (%r)", proxiee)
-        return proxiee.__enter__()
-
-    def __exit__(self, exc_type, exc_value, traceback):
-        proxiee = type(self).__proxiee__
-        _logger.debug("__exit__ on proxiee (%r)", proxiee)
-        return proxiee.__exit__(exc_type, exc_value, traceback)
-
-
-class proxy(proxy_base, metaclass=proxy_meta):
-    """
-    A mostly transparent proxy type
-
-    The proxy class can be used in two different ways. First, as a callable
-    ``proxy(obj)``. This simply returns a proxy for a single object.
-
-        >>> truth = ['trust no one']
-        >>> lie = proxy(truth)
-
-    This will return an instance of a new ``proxy`` sub-class which for all
-    intents and purposes, to the extent possible in CPython, forwards all
-    requests to the original object.
-
-    One can still examine the proxy with some ways::
-
-        >>> lie is truth
-        False
-        >>> type(lie) is type(truth)
-        False
-
-    Having said that, the vast majority of stuff will make the proxy behave
-    identically to the original object.
-
-        >>> lie[0]
-        'trust no one'
-        >>> lie[0] = 'trust the government'
-        >>> truth[0]
-        'trust the government'
-
-    The second way of using the ``proxy`` class is as a base class. In this
-    way, one can actually override certain methods. To ensure that all the
-    dunder methods work correctly please use the ``@unproxied`` decorator on
-    them.
-
-        >>> import codecs
-        >>> class crypto(proxy):
-        ...
-        ...     @unproxied
-        ...     def __repr__(self):
-        ...         return codecs.encode(super().__repr__(), "rot_13")
-
-    With this weird class, we can change the repr() of any object we want to be
-    ROT-13 encoded. Let's see:
-
-        >>> orig = ['ala ma kota', 'a kot ma ale']
-        >>> prox = crypto(orig)
-
-    We can sill access all of the data through the proxy:
-
-        >>> prox[0]
-        'ala ma kota'
-
-    But the whole repr() is now a bit different than usual:
-
-        >>> prox
-        ['nyn zn xbgn', 'n xbg zn nyr']
-    """
-
-    def __new__(proxy_cls, proxiee):
-        """
-        Create a new instance of ``proxy()`` wrapping ``proxiee``
-
-        :param proxiee:
-            The object to proxy
-        :returns:
-            An instance of new subclass of ``proxy``, called
-            ``boundproxy[proxiee]`` that uses a new meta-class that lexically
-            bounds the ``proxiee`` argument. The new sub-class has a different
-            implementation of ``__new__`` and can be instantiated without
-            additional arguments.
-        """
-        _logger.debug("__new__ on proxy with proxiee: %r", proxiee)
-        boundproxy_meta = make_boundproxy_meta(proxiee)
-
-        class boundproxy(proxy_cls, metaclass=boundproxy_meta):
-
-            def __new__(boundproxy_cls):
-                _logger.debug("__new__ on boundproxy %r", boundproxy_cls)
-                return object.__new__(boundproxy_cls)
-        return boundproxy()
-
-
-def unproxied(fn):
-    """
-    Mark an object (attribute) as not-to-be-proxied.
-
-    This decorator can be used inside :class:`proxy` sub-classes. Please
-    consult the documentation of ``proxy`` for details.
-    """
-    fn.unproxied = True
-    return fn

=== removed file 'plainbox/plainbox/impl/test_proxy.py'
--- plainbox/plainbox/impl/test_proxy.py	2015-08-31 10:05:19 +0000
+++ plainbox/plainbox/impl/test_proxy.py	1970-01-01 00:00:00 +0000
@@ -1,376 +0,0 @@
-# This file is part of Checkbox.
-#
-# Copyright 2012-2015 Canonical Ltd.
-# Written by:
-#   Zygmunt Krynicki <[e-mail]>
-#
-# Checkbox is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License version 3,
-# as published by the Free Software Foundation.
-#
-# Checkbox is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
-import doctest
-import operator
-import sys
-import unittest
-
-from plainbox.impl.proxy import _logger
-from plainbox.impl.proxy import proxy
-from plainbox.impl.proxy import unproxied
-from plainbox.vendor import mock
-
-
-# XXX: Set to True for revelation
-reality_is_broken = False
-
-
-def load_tests(loader, tests, ignore):
-    tests.addTests(
-        doctest.DocTestSuite('plainbox.impl.proxy',
-                             optionflags=doctest.REPORT_NDIFF))
-    return tests
-
-
-def setUpModule():
-    if reality_is_broken:
-        # If you start to doubt reality
-        from plainbox.impl.logging import adjust_logging
-        from plainbox.impl.logging import setup_logging
-        setup_logging()
-        adjust_logging('DEBUG', ['plainbox.proxy'], True)
-
-
-class proxy_as_function(unittest.TestCase):
-
-    def setUp(self):
-        if reality_is_broken:
-            print()
-            _logger.debug("STARTING")
-            _logger.debug("[%s]", self._testMethodName)
-        self.obj = mock.MagicMock(name='obj')
-        self.proxy = proxy(self.obj)
-
-    def tearDown(self):
-        if reality_is_broken:
-            _logger.debug("DONE")
-
-    # NOTE: order of test methods matches implementation
-
-    def test_repr(self):
-        self.assertEqual(repr(self.proxy), repr(self.obj))
-        self.assertEqual(self.proxy.__repr__(), repr(self.obj))
-
-    def test_str(self):
-        self.assertEqual(str(self.proxy), str(self.obj))
-        self.assertEqual(self.proxy.__str__(), str(self.obj))
-
-    def test_bytes(self):
-        # NOTE: bytes() is unlike str() or repr() in that it is not a function
-        # that converts an arbitrary object into a bytes object.  We cannot
-        # just call it on a random object. What we must do is implement
-        # __bytes__() on a new class and use instances of that class.
-        class C:
-            def __bytes__(self):
-                return b'good'
-        self.obj = C()
-        self.proxy = proxy(self.obj)
-        self.assertEqual(bytes(self.proxy), bytes(self.obj))
-        self.assertEqual(self.proxy.__bytes__(), bytes(self.obj))
-
-    def test_format(self):
-        self.assertEqual(format(self.proxy), format(self.obj))
-        self.assertEqual(self.proxy.__format__(""), format(self.obj))
-
-    def test_lt(self):
-        # NOTE: MagicMock is not ordered so let's just use an integer
-        self.obj = 0
-        self.proxy = proxy(self.obj)
-        self.assertLess(self.proxy, 1)
-        self.assertLess(self.obj, 1)
-
-    def test_le(self):
-        # NOTE: MagicMock is not ordered so let's just use an integer
-        self.obj = 0
-        self.proxy = proxy(self.obj)
-        self.assertLessEqual(self.proxy, 0)
-        self.assertLessEqual(self.proxy, 1)
-        self.assertLessEqual(self.obj, 0)
-        self.assertLessEqual(self.obj, 1)
-
-    def test_eq(self):
-        self.assertEqual(self.proxy, self.obj)
-        self.obj.__eq__.assert_called_once_with(self.obj)
-        self.assertEqual(self.obj, self.obj)
-
-    def test_ne(self):
-        other = object()
-        self.assertNotEqual(self.proxy, other)
-        self.obj.__ne__.assert_called_once_with(other)
-        self.assertNotEqual(self.obj, object())
-
-    def test_gt(self):
-        # NOTE: MagicMock is not ordered so let's just use an integer
-        self.obj = 0
-        self.proxy = proxy(self.obj)
-        self.assertGreater(self.proxy, -1)
-        self.assertGreater(self.obj, -1)
-
-    def test_ge(self):
-        # NOTE: MagicMock is not ordered so let's just use an integer
-        self.obj = 0
-        self.proxy = proxy(self.obj)
-        self.assertGreaterEqual(self.proxy, 0)
-        self.assertGreaterEqual(self.proxy, -1)
-        self.assertGreaterEqual(self.obj, 0)
-        self.assertGreaterEqual(self.obj, -1)
-
-    def test_hash(self):
-        self.assertEqual(hash(self.proxy), hash(self.obj))
-        self.assertEqual(self.proxy.__hash__(), hash(self.obj))
-
-    def test_bool(self):
-        self.assertEqual(bool(self.proxy), bool(self.obj))
-        self.assertEqual(self.proxy.__bool__(), bool(self.obj))
-
-    def test_attr_get(self):
-        self.assertIs(self.proxy.attr, self.obj.attr)
-
-    def test_attr_set(self):
-        value = mock.Mock(name='value')
-        self.proxy.attr = value
-        self.assertIs(self.obj.attr, value)
-
-    def test_attr_del(self):
-        del self.proxy.attr
-        with self.assertRaises(AttributeError):
-            self.obj.attr
-
-    def test_dir(self):
-        self.assertEqual(dir(self.proxy), dir(self.obj))
-        self.assertEqual(self.proxy.__dir__(), dir(self.obj))
-
-    def test_descriptor_methods(self):
-        # NOTE: this tests __get__, __set__ and __delete__ in one test, for
-        # brevity
-        property_proxy = proxy(property)
-
-        class C:
-            _ok = "default"
-
-            @property_proxy
-            def ok(self):
-                return self._ok
-
-            @ok.setter
-            def ok(self, value):
-                self._ok = value
-
-            @ok.deleter
-            def ok(self):
-                del self._ok
-        obj = C()
-        self.assertEqual(obj._ok, "default")
-        # __set__ assigns the new value
-        obj.ok = True
-        self.assertTrue(obj._ok)
-        # __get__ returns the current value
-        self.assertTrue(obj.ok)
-        # __delete__ removes the current value
-        del obj.ok
-        self.assertEqual(obj._ok, "default")
-
-    def test_call(self):
-        self.assertEqual(self.proxy(), self.obj())
-        self.assertEqual(self.proxy.__call__(), self.obj())
-
-    def test_len(self):
-        self.assertEqual(len(self.proxy), len(self.obj))
-        self.assertEqual(self.proxy.__len__(), len(self.obj))
-
-    @unittest.skipIf(lambda: sys.version_info[0:2] < 3, 4)
-    def test_length_hint(self):
-        # NOTE: apparently MagicMock doesn't support this method
-        class C:
-            def __length_hint__(self):
-                return 42
-        self.obj = C()
-        self.proxy = proxy(self.obj)
-        self.assertEqual(
-            operator.length_hint(self.proxy), operator.length_hint(self.obj))
-        self.assertEqual(
-            self.proxy.__length_hint__(), operator.length_hint(self.obj))
-
-    def test_getitem(self):
-        self.assertEqual(self.proxy['item'], self.obj['item'])
-        self.assertEqual(self.proxy.__getitem__('item'), self.obj['item'])
-
-    def test_setitem_v1(self):
-        # NOTE: MagicMock doesn't store item assignment
-        self.obj = ["old"]
-        self.proxy = proxy(self.obj)
-        self.proxy[0] = "new"
-        self.assertEqual(self.obj[0], "new")
-
-    def test_setitem_v2(self):
-        # NOTE: MagicMock doesn't store item assignment
-        self.obj = ["old"]
-        self.proxy = proxy(self.obj)
-        self.proxy.__setitem__(0, "value")
-        self.assertEqual(self.obj[0], "value")
-
-    def test_delitem(self):
-        obj = {'k': 'v'}
-        del proxy(obj)['k']
-        self.assertEqual(obj, {})
-        obj = {'k': 'v'}
-        proxy(obj).__delitem__('k')
-        self.assertEqual(obj, {})
-
-    def test_iter(self):
-        # NOTE: MagicMock.__iter__ needs to return a deterministic iterator as
-        # by default a new iterator is returned each time.
-        self.obj.__iter__.return_value = iter([])
-        self.assertEqual(iter(self.proxy), iter(self.obj))
-        self.assertEqual(self.proxy.__iter__(), iter(self.obj))
-
-    def test_reversed(self):
-        # NOTE: apparently MagicMock.doesn't support __reversed__ so we fall
-        # back to the approach with a custom class. The same comment, as above,
-        # for __iter__() applies though.
-        with self.assertRaises(AttributeError):
-            self.obj.__reversed__.return_value = reversed([])
-
-        class C:
-            reversed_retval = iter([])
-
-            def __reversed__(self):
-                return self.reversed_retval
-        self.obj = C()
-        self.proxy = proxy(self.obj)
-        self.assertEqual(reversed(self.proxy), reversed(self.obj))
-        self.assertEqual(self.proxy.__reversed__(), reversed(self.obj))
-
-    def test_contains(self):
-        item = object()
-        self.assertEqual(item in self.proxy, item in self.obj)
-        self.assertEqual(self.proxy.__contains__(item), item in self.obj)
-        self.assertEqual(self.proxy.__contains__(item), False)
-        self.obj.__contains__.return_value = True
-        self.assertEqual(item in self.proxy, item in self.obj)
-        self.assertEqual(self.proxy.__contains__(item), item in self.obj)
-        self.assertEqual(self.proxy.__contains__(item), True)
-
-    # TODO, tests and implementation for all the numeric methods
-
-    def test_context_manager_methods_v1(self):
-        with self.proxy:
-            pass
-        self.obj.__enter__.assert_called_once_with()
-        self.obj.__exit__.assert_called_once_with(None, None, None)
-
-    def test_context_manager_methods_v2(self):
-        exc = Exception("boom")
-        exc_info = ()
-        with self.assertRaisesRegex(Exception, "boom"):
-            try:
-                with self.proxy:
-                    raise exc
-            except Exception:
-                exc_info = sys.exc_info()
-                raise
-        self.obj.__enter__.assert_called_once_with()
-        self.obj.__exit__.assert_called_once_with(*exc_info)
-
-    def test_hasattr_parity(self):
-        class C():
-            pass
-        special_methods = '''
-            __del__
-            __repr__
-            __str__
-            __bytes__
-            __format__
-            __lt__
-            __le__
-            __eq__
-            __ne__
-            __gt__
-            __ge__
-            __hash__
-            __bool__
-            __getattr__
-            __getattribute__
-            __setattr__
-            __delattr__
-            __dir__
-            __get__
-            __set__
-            __delete__
-            __call__
-            __len__
-            __length_hint__
-            __getitem__
-            __setitem__
-            __delitem__
-            __iter__
-            __reversed__
-            __contains__
-            __enter__
-            __exit__
-        '''.split()
-        for obj in [C(), 42, property(lambda x: x), int, None]:
-            self.obj = obj
-            self.proxy = proxy(self.obj)
-            for attr in special_methods:
-                self.assertEqual(
-                    hasattr(self.obj, attr),
-                    hasattr(self.proxy, attr),
-                    "attribute presence mismatch on attr %r and object %r" % (
-                        attr, self.obj))
-
-    def test_isinstance(self):
-        # NOTE: this method tests the metaclass
-        self.assertIsInstance(self.obj, type(self.obj))
-        self.assertIsInstance(self.proxy, type(self.obj))
-
-    def test_issubclass(self):
-        # NOTE: this method tests the metaclass
-        # NOTE: mock doesn't support subclasscheck
-        obj = "something other than mock"
-        self.assertTrue(issubclass(str, type(obj)))
-        self.assertTrue(issubclass(str, type(proxy(obj))))
-
-    def test_class(self):
-        self.assertEqual(self.proxy.__class__, self.obj.__class__)
-        # NOTE: The proxy cannot hide the fact, that it is a proxy
-        self.assertNotEqual(type(self.proxy), type(self.obj))
-
-
-class proxy_as_class(unittest.TestCase):
-
-    def setUp(self):
-        if reality_is_broken:
-            print()
-            _logger.debug("STARTING")
-            _logger.debug("[%s]", self._testMethodName)
-
-    def tearDown(self):
-        if reality_is_broken:
-            _logger.debug("DONE")
-
-    def test_proxy_subclass(self):
-        # NOTE: bring your comb, because this is the extra-hairy land
-        class censored(proxy):
-
-            @unproxied
-            def __str__(self):
-                return "*" * len(super().__str__())
-        self.assertTrue(issubclass(censored, proxy))
-        self.assertEqual(str(censored("freedom")), "*******")
-        self.assertEqual(censored("freedom").__str__(), "*******")

=== modified file 'plainbox/requirements/deb-core.txt'
--- plainbox/requirements/deb-core.txt	2015-06-25 16:46:15 +0000
+++ plainbox/requirements/deb-core.txt	2015-08-31 14:17:15 +0000
@@ -1,3 +1,4 @@
 policykit-1
 python3-jinja2
+python3-padme
 python3-xlsxwriter

=== modified file 'plainbox/setup.py'
--- plainbox/setup.py	2015-08-03 14:10:44 +0000
+++ plainbox/setup.py	2015-08-31 14:17:15 +0000
@@ -72,6 +72,7 @@
     ],
     install_requires=[
         'Jinja2 >= 2.7',
+        'padme >= 1.1.1',
         'requests >= 1.0',
     ],
     extras_require={