Application: gvSIG desktop » gvSIG scripting

import operator

from .compat import PY2

from .compat import PY3

from .compat import with_metaclass

from .utils import cached_property

from .utils import identity

def make_proxy_method(code):

    def proxy_wrapper(self, *args):

        return code(self.__wrapped__, *args)

    return proxy_wrapper

class _ProxyMethods(object):

    # We use properties to override the values of __module__ and

    # __doc__. If we add these in ObjectProxy, the derived class

    # __dict__ will still be setup to have string variants of these

    # attributes and the rules of descriptors means that they appear to

    # take precedence over the properties in the base class. To avoid

    # that, we copy the properties into the derived class type itself

    # via a meta class. In that way the properties will always take

    # precedence.

    @property

    def __module__(self):

        return self.__wrapped__.__module__

    @__module__.setter

    def __module__(self, value):

        self.__wrapped__.__module__ = value

    @property

    def __doc__(self):

        return self.__wrapped__.__doc__

    @__doc__.setter

    def __doc__(self, value):

        self.__wrapped__.__doc__ = value

    # Need to also propagate the special __weakref__ attribute for case

    # where decorating classes which will define this. If do not define

    # it and use a function like inspect.getmembers() on a decorator

    # class it will fail. This can't be in the derived classes.

    @property

    def __weakref__(self):

        return self.__wrapped__.__weakref__

class _ProxyMetaType(type):

    def __new__(cls, name, bases, dictionary):

        # Copy our special properties into the class so that they

        # always take precedence over attributes of the same name added

        # during construction of a derived class. This is to save

        # duplicating the implementation for them in all derived classes.

        dictionary.update(vars(_ProxyMethods))

        dictionary.pop('__dict__')

        return type.__new__(cls, name, bases, dictionary)

class Proxy(with_metaclass(_ProxyMetaType)):

    __factory__ = None

    def __init__(self, factory):

        self.__dict__['__factory__'] = factory

    @cached_property

    def __wrapped__(self):

        self = self.__dict__

        if '__factory__' in self:

            factory = self['__factory__']

            return factory()

        else:

            raise ValueError("Proxy hasn't been initiated: __factory__ is missing.")

    __name__ = property(make_proxy_method(operator.attrgetter('__name__')))

    __class__ = property(make_proxy_method(operator.attrgetter('__class__')))

    __annotations__ = property(make_proxy_method(operator.attrgetter('__anotations__')))

    __dir__ = make_proxy_method(dir)

    __str__ = make_proxy_method(str)

    if PY3:

        __bytes__ = make_proxy_method(bytes)

    def __repr__(self, __getattr__=object.__getattribute__):

        if '__wrapped__' in self.__dict__:

            return '<%s at 0x%x wrapping %r at 0x%x with factory %r>' % (

                type(self).__name__, id(self),

                self.__wrapped__, id(self.__wrapped__),

                self.__factory__

            )

        else:

            return '<%s at 0x%x with factory %r>' % (

                type(self).__name__, id(self),

                self.__factory__

            )

    __reversed__ = make_proxy_method(reversed)

    if PY3:

        __round__ = make_proxy_method(round)

    __lt__ = make_proxy_method(operator.lt)

    __le__ = make_proxy_method(operator.le)

    __eq__ = make_proxy_method(operator.eq)

    __ne__ = make_proxy_method(operator.ne)

    __gt__ = make_proxy_method(operator.gt)

    __ge__ = make_proxy_method(operator.ge)

    __hash__ = make_proxy_method(hash)

    __nonzero__ = make_proxy_method(bool)

    __bool__ = make_proxy_method(bool)

    def __setattr__(self, name, value):

        if hasattr(type(self), name):

            self.__dict__[name] = value

        else:

            setattr(self.__wrapped__, name, value)

    def __getattr__(self, name):

        if name in ('__wrapped__', '__factory__'):

            raise AttributeError(name)

        else:

            return getattr(self.__wrapped__, name)

    def __delattr__(self, name):

        if hasattr(type(self), name):

            del self.__dict__[name]

        else:

            delattr(self.__wrapped__, name)

    __add__ = make_proxy_method(operator.add)

    __sub__ = make_proxy_method(operator.sub)

    __mul__ = make_proxy_method(operator.mul)

    __div__ = make_proxy_method(operator.div if PY2 else operator.truediv)

    __truediv__ = make_proxy_method(operator.truediv)

    __floordiv__ = make_proxy_method(operator.floordiv)

    __mod__ = make_proxy_method(operator.mod)

    __divmod__ = make_proxy_method(divmod)

    __pow__ = make_proxy_method(pow)

    __lshift__ = make_proxy_method(operator.lshift)

    __rshift__ = make_proxy_method(operator.rshift)

    __and__ = make_proxy_method(operator.and_)

    __xor__ = make_proxy_method(operator.xor)

    __or__ = make_proxy_method(operator.or_)

    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 __rdiv__(self, other):

        return operator.div(other, self.__wrapped__)

    def __rtruediv__(self, other):

        return operator.truediv(other, self.__wrapped__)

    def __rfloordiv__(self, other):

        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, *args):

        return pow(other, self.__wrapped__, *args)

    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__

    __iadd__ = make_proxy_method(operator.iadd)

    __isub__ = make_proxy_method(operator.isub)

    __imul__ = make_proxy_method(operator.imul)

    __idiv__ = make_proxy_method(operator.idiv if PY2 else operator.itruediv)

    __itruediv__ = make_proxy_method(operator.itruediv)

    __ifloordiv__ = make_proxy_method(operator.ifloordiv)

    __imod__ = make_proxy_method(operator.imod)

    __ipow__ = make_proxy_method(operator.ipow)

    __ilshift__ = make_proxy_method(operator.ilshift)

    __irshift__ = make_proxy_method(operator.irshift)

    __iand__ = make_proxy_method(operator.iand)

    __ixor__ = make_proxy_method(operator.ixor)

    __ior__ = make_proxy_method(operator.ior)

    __neg__ = make_proxy_method(operator.neg)

    __pos__ = make_proxy_method(operator.pos)

    __abs__ = make_proxy_method(operator.abs)

    __invert__ = make_proxy_method(operator.invert)

    __int__ = make_proxy_method(int)

    if PY2:

        __long__ = make_proxy_method(long)  # flake8: noqa

    __float__ = make_proxy_method(float)

    __oct__ = make_proxy_method(oct)

    __hex__ = make_proxy_method(hex)

    __index__ = make_proxy_method(operator.index)

    __len__ = make_proxy_method(len)

    __contains__ = make_proxy_method(operator.contains)

    __getitem__ = make_proxy_method(operator.getitem)

    __setitem__ = make_proxy_method(operator.setitem)

    __delitem__ = make_proxy_method(operator.delitem)

    if PY2:

        __getslice__ = make_proxy_method(operator.getslice)

        __setslice__ = make_proxy_method(operator.setslice)

        __delslice__ = make_proxy_method(operator.delslice)

    def __enter__(self):

        return self.__wrapped__.__enter__()

    def __exit__(self, *args, **kwargs):

        return self.__wrapped__.__exit__(*args, **kwargs)

    __iter__ = make_proxy_method(iter)

    def __call__(self, *args, **kwargs):

        return self.__wrapped__(*args, **kwargs)

    def __reduce__(self):

        return identity, (self.__wrapped__,)

    def __reduce_ex__(self, protocol):

        return identity, (self.__wrapped__,)

/* ------------------------------------------------------------------------- */

#include "Python.h"

#include "structmember.h"

#ifndef PyVarObject_HEAD_INIT

#define PyVarObject_HEAD_INIT(type, size) PyObject_HEAD_INIT(type) size,

#endif

#define Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(object) \

    if (PyObject_IsInstance(object, (PyObject *)&Proxy_Type)) { \

        object = Proxy__ensure_wrapped((ProxyObject *)object); \

        if (!object) return NULL; \

    }

#define Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self) if (!Proxy__ensure_wrapped(self)) return NULL;

#define Proxy__ENSURE_WRAPPED_OR_RETURN_MINUS1(self) if (!Proxy__ensure_wrapped(self)) return -1;

#if PY_MAJOR_VERSION < 3

#define Py_hash_t long

#endif

/* ------------------------------------------------------------------------- */

typedef struct {

    PyObject_HEAD

    PyObject *dict;

    PyObject *wrapped;

    PyObject *factory;

} ProxyObject;

PyTypeObject Proxy_Type;

/* ------------------------------------------------------------------------- */

static PyObject *identity_ref = NULL;

static PyObject *

identity(PyObject *self, PyObject *value)

{

    Py_INCREF(value);

    return value;

}

/* ------------------------------------------------------------------------- */

PyDoc_STRVAR(identity_doc, "Indentity function: returns the single argument.");

static struct PyMethodDef module_functions[] = {

    {"identity", identity, METH_O, identity_doc},

    {NULL,       NULL}

};

/* ------------------------------------------------------------------------- */

static PyObject *Proxy__ensure_wrapped(ProxyObject *self)

{

    PyObject *wrapped;

    if (self->wrapped) {

        return self->wrapped;

    } else {

        if (self->factory) {

            wrapped = PyObject_CallFunctionObjArgs(self->factory, NULL);

            if (wrapped) {

                self->wrapped = wrapped;

                return wrapped;

            } else {

                return NULL;

            }

        } else {

            PyErr_SetString(PyExc_ValueError, "Proxy hasn't been initiated: __factory__ is missing.");

            return NULL;

        }

    }

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_new(PyTypeObject *type,

        PyObject *args, PyObject *kwds)

{

    ProxyObject *self;

    self = (ProxyObject *)type->tp_alloc(type, 0);

    if (!self)

        return NULL;

    self->dict = PyDict_New();

    self->wrapped = NULL;

    self->factory = NULL;

    return (PyObject *)self;

}

/* ------------------------------------------------------------------------- */

static int Proxy_raw_init(ProxyObject *self,

        PyObject *factory)

{

    Py_INCREF(factory);

    Py_XDECREF(self->wrapped);

    Py_XDECREF(self->factory);

    self->factory = factory;

    return 0;

}

/* ------------------------------------------------------------------------- */

static int Proxy_init(ProxyObject *self,

        PyObject *args, PyObject *kwds)

{

    PyObject *wrapped = NULL;

    static char *kwlist[] = { "wrapped", NULL };

    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O:ObjectProxy",

            kwlist, &wrapped)) {

        return -1;

    }

    return Proxy_raw_init(self, wrapped);

}

/* ------------------------------------------------------------------------- */

static int Proxy_traverse(ProxyObject *self,

        visitproc visit, void *arg)

{

    Py_VISIT(self->dict);

    Py_VISIT(self->wrapped);

    Py_VISIT(self->factory);

    return 0;

}

/* ------------------------------------------------------------------------- */

static int Proxy_clear(ProxyObject *self)

{

    Py_CLEAR(self->dict);

    Py_CLEAR(self->wrapped);

    Py_CLEAR(self->factory);

    return 0;

}

/* ------------------------------------------------------------------------- */

static void Proxy_dealloc(ProxyObject *self)

{

    PyObject_GC_UnTrack(self);

    Proxy_clear(self);

    Py_TYPE(self)->tp_free(self);

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_repr(ProxyObject *self)

{

#if PY_MAJOR_VERSION < 3

    PyObject *factory_repr;

    factory_repr = PyObject_Repr(self->factory);

    if (factory_repr == NULL)

        return NULL;

#endif

    if (self->wrapped) {

#if PY_MAJOR_VERSION >= 3

        return PyUnicode_FromFormat("<%s at %p wrapping %R at %p with factory %R>",

                Py_TYPE(self)->tp_name, self,

                self->wrapped, self->wrapped,

                self->factory);

#else

        PyObject *wrapped_repr;

        wrapped_repr = PyObject_Repr(self->wrapped);

        if (wrapped_repr == NULL)

            return NULL;

        return PyString_FromFormat("<%s at %p wrapping %s at %p with factory %s>",

                Py_TYPE(self)->tp_name, self,

                PyString_AS_STRING(wrapped_repr), self->wrapped,

                PyString_AS_STRING(factory_repr));

#endif

    } else {

#if PY_MAJOR_VERSION >= 3

        return PyUnicode_FromFormat("<%s at %p with factory %R>",

                Py_TYPE(self)->tp_name, self,

                self->factory);

#else

        return PyString_FromFormat("<%s at %p with factory %s>",

                Py_TYPE(self)->tp_name, self,

                PyString_AS_STRING(factory_repr));

#endif

    }

}

/* ------------------------------------------------------------------------- */

static Py_hash_t Proxy_hash(ProxyObject *self)

{

    Proxy__ENSURE_WRAPPED_OR_RETURN_MINUS1(self);

    return PyObject_Hash(self->wrapped);

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_str(ProxyObject *self)

{

    Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

    return PyObject_Str(self->wrapped);

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_add(PyObject *o1, PyObject *o2)

{

    Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(o1);

    Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(o2);

    return PyNumber_Add(o1, o2);

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_subtract(PyObject *o1, PyObject *o2)

{

    Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(o1);

    Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(o2);

    return PyNumber_Subtract(o1, o2);

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_multiply(PyObject *o1, PyObject *o2)

{

    Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(o1);

    Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(o2);

    return PyNumber_Multiply(o1, o2);

}

/* ------------------------------------------------------------------------- */

#if PY_MAJOR_VERSION < 3

static PyObject *Proxy_divide(PyObject *o1, PyObject *o2)

{

    Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(o1);

    Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(o2);

    return PyNumber_Divide(o1, o2);

}

#endif

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_remainder(PyObject *o1, PyObject *o2)

{

    Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(o1);

    Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(o2);

    return PyNumber_Remainder(o1, o2);

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_divmod(PyObject *o1, PyObject *o2)

{

    Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(o1);

    Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(o2);

    return PyNumber_Divmod(o1, o2);

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_power(PyObject *o1, PyObject *o2,

        PyObject *modulo)

{

    Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(o1);

    Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(o2);

    return PyNumber_Power(o1, o2, modulo);

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_negative(ProxyObject *self)

{

    Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

    return PyNumber_Negative(self->wrapped);

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_positive(ProxyObject *self)

{

    Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

    return PyNumber_Positive(self->wrapped);

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_absolute(ProxyObject *self)

{

    Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

    return PyNumber_Absolute(self->wrapped);

}

/* ------------------------------------------------------------------------- */

static int Proxy_bool(ProxyObject *self)

{

    Proxy__ENSURE_WRAPPED_OR_RETURN_MINUS1(self);

    return PyObject_IsTrue(self->wrapped);

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_invert(ProxyObject *self)

{

    Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

    return PyNumber_Invert(self->wrapped);

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_lshift(PyObject *o1, PyObject *o2)

{

    Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(o1);

    Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(o2);

    return PyNumber_Lshift(o1, o2);

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_rshift(PyObject *o1, PyObject *o2)

{

    Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(o1);

    Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(o2);

    return PyNumber_Rshift(o1, o2);

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_and(PyObject *o1, PyObject *o2)

{

    Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(o1);

    Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(o2);

    return PyNumber_And(o1, o2);

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_xor(PyObject *o1, PyObject *o2)

{

    Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(o1);

    Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(o2);

    return PyNumber_Xor(o1, o2);

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_or(PyObject *o1, PyObject *o2)

{

    Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(o1);

    Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(o2);

    return PyNumber_Or(o1, o2);

}

/* ------------------------------------------------------------------------- */

#if PY_MAJOR_VERSION < 3

static PyObject *Proxy_int(ProxyObject *self)

{

    Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

    return PyNumber_Int(self->wrapped);

}

#endif

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_long(ProxyObject *self)

{

    Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

    return PyNumber_Long(self->wrapped);

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_float(ProxyObject *self)

{

    Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

    return PyNumber_Float(self->wrapped);

}

/* ------------------------------------------------------------------------- */

#if PY_MAJOR_VERSION < 3

static PyObject *Proxy_oct(ProxyObject *self)

{

    PyNumberMethods *nb;

    Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

    if ((nb = self->wrapped->ob_type->tp_as_number) == NULL ||

        nb->nb_oct == NULL) {

        PyErr_SetString(PyExc_TypeError,

                   "oct() argument can't be converted to oct");

        return NULL;

    }

    return (*nb->nb_oct)(self->wrapped);

}

#endif

/* ------------------------------------------------------------------------- */

#if PY_MAJOR_VERSION < 3

static PyObject *Proxy_hex(ProxyObject *self)

{

    PyNumberMethods *nb;

    Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

    if ((nb = self->wrapped->ob_type->tp_as_number) == NULL ||

        nb->nb_hex == NULL) {

        PyErr_SetString(PyExc_TypeError,

                   "hex() argument can't be converted to hex");

        return NULL;

    }

    return (*nb->nb_hex)(self->wrapped);

}

#endif

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_inplace_add(ProxyObject *self,

        PyObject *other)

{

    PyObject *object = NULL;

    Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

    Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(other);

    object = PyNumber_InPlaceAdd(self->wrapped, other);

    if (!object)

        return NULL;

    Py_DECREF(self->wrapped);

    self->wrapped = object;

    Py_INCREF(self);

    return (PyObject *)self;

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_inplace_subtract(

        ProxyObject *self, PyObject *other)

{

    PyObject *object = NULL;

    Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

    Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(other);

    object = PyNumber_InPlaceSubtract(self->wrapped, other);

    if (!object)

        return NULL;

    Py_DECREF(self->wrapped);

    self->wrapped = object;

    Py_INCREF(self);

    return (PyObject *)self;

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_inplace_multiply(

        ProxyObject *self, PyObject *other)

{

    PyObject *object = NULL;

    Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

    Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(other);

    object = PyNumber_InPlaceMultiply(self->wrapped, other);

    if (!object)

        return NULL;

    Py_DECREF(self->wrapped);

    self->wrapped = object;

    Py_INCREF(self);

    return (PyObject *)self;

}

/* ------------------------------------------------------------------------- */

#if PY_MAJOR_VERSION < 3

static PyObject *Proxy_inplace_divide(

        ProxyObject *self, PyObject *other)

{

    PyObject *object = NULL;

    Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

    Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(other);

    object = PyNumber_InPlaceDivide(self->wrapped, other);

    if (!object)

        return NULL;

    Py_DECREF(self->wrapped);

    self->wrapped = object;

    Py_INCREF(self);

    return (PyObject *)self;

}

#endif

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_inplace_remainder(

        ProxyObject *self, PyObject *other)

{

    PyObject *object = NULL;

    Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

    Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(other);

    object = PyNumber_InPlaceRemainder(self->wrapped, other);

    if (!object)

        return NULL;

    Py_DECREF(self->wrapped);

    self->wrapped = object;

    Py_INCREF(self);

    return (PyObject *)self;

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_inplace_power(ProxyObject *self,

        PyObject *other, PyObject *modulo)

{

    PyObject *object = NULL;

    Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

    Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(other);

    object = PyNumber_InPlacePower(self->wrapped, other, modulo);

    if (!object)

        return NULL;

    Py_DECREF(self->wrapped);

    self->wrapped = object;

    Py_INCREF(self);

    return (PyObject *)self;

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_inplace_lshift(ProxyObject *self,

        PyObject *other)

{

    PyObject *object = NULL;

    Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

    Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(other);

    object = PyNumber_InPlaceLshift(self->wrapped, other);

    if (!object)

        return NULL;

    Py_DECREF(self->wrapped);

    self->wrapped = object;

    Py_INCREF(self);

    return (PyObject *)self;

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_inplace_rshift(ProxyObject *self,

        PyObject *other)

{

    PyObject *object = NULL;

    Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

    Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(other);

    object = PyNumber_InPlaceRshift(self->wrapped, other);

    if (!object)

        return NULL;

    Py_DECREF(self->wrapped);

    self->wrapped = object;

    Py_INCREF(self);

    return (PyObject *)self;

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_inplace_and(ProxyObject *self,

        PyObject *other)

{

    PyObject *object = NULL;

    Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

    Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(other);

    object = PyNumber_InPlaceAnd(self->wrapped, other);

    if (!object)

        return NULL;

    Py_DECREF(self->wrapped);

    self->wrapped = object;

    Py_INCREF(self);

    return (PyObject *)self;

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_inplace_xor(ProxyObject *self,

        PyObject *other)

{

    PyObject *object = NULL;

    Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

    Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(other);

    object = PyNumber_InPlaceXor(self->wrapped, other);

    if (!object)

        return NULL;

    Py_DECREF(self->wrapped);

    self->wrapped = object;

    Py_INCREF(self);

    return (PyObject *)self;

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_inplace_or(ProxyObject *self,

        PyObject *other)

{

    PyObject *object = NULL;

    Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

    Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(other);

    object = PyNumber_InPlaceOr(self->wrapped, other);

    Py_DECREF(self->wrapped);

    self->wrapped = object;

    Py_INCREF(self);

    return (PyObject *)self;

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_floor_divide(PyObject *o1, PyObject *o2)

{

    Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(o1);

    Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(o2);

    return PyNumber_FloorDivide(o1, o2);

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_true_divide(PyObject *o1, PyObject *o2)

{

    Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(o1);

    Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(o2);

    return PyNumber_TrueDivide(o1, o2);

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_inplace_floor_divide(

        ProxyObject *self, PyObject *other)

{

    PyObject *object = NULL;

    Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

    Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(other);

    object = PyNumber_InPlaceFloorDivide(self->wrapped, other);

    if (!object)

        return NULL;

    Py_DECREF(self->wrapped);

    self->wrapped = object;

    Py_INCREF(self);

    return (PyObject *)self;

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_inplace_true_divide(

        ProxyObject *self, PyObject *other)

{

    PyObject *object = NULL;

    Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

    Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(other);

    object = PyNumber_InPlaceTrueDivide(self->wrapped, other);

    if (!object)

        return NULL;

    Py_DECREF(self->wrapped);

    self->wrapped = object;

    Py_INCREF(self);

    return (PyObject *)self;

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_index(ProxyObject *self)

{

    Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

    return PyNumber_Index(self->wrapped);

}

/* ------------------------------------------------------------------------- */

static Py_ssize_t Proxy_length(ProxyObject *self)

{

    Proxy__ENSURE_WRAPPED_OR_RETURN_MINUS1(self);

    return PyObject_Length(self->wrapped);

}

/* ------------------------------------------------------------------------- */

static int Proxy_contains(ProxyObject *self,

        PyObject *value)

{

    Proxy__ENSURE_WRAPPED_OR_RETURN_MINUS1(self);

    return PySequence_Contains(self->wrapped, value);

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_getitem(ProxyObject *self,

        PyObject *key)

{

    Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

    return PyObject_GetItem(self->wrapped, key);

}

/* ------------------------------------------------------------------------- */

static int Proxy_setitem(ProxyObject *self,

        PyObject *key, PyObject* value)

{

    Proxy__ENSURE_WRAPPED_OR_RETURN_MINUS1(self);

    if (value == NULL)

        return PyObject_DelItem(self->wrapped, key);

    else

        return PyObject_SetItem(self->wrapped, key, value);

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_dir(

        ProxyObject *self, PyObject *args)

{

    Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

    return PyObject_Dir(self->wrapped);

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_enter(

        ProxyObject *self, PyObject *args, PyObject *kwds)

{

    PyObject *method = NULL;

    PyObject *result = NULL;

    Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

    method = PyObject_GetAttrString(self->wrapped, "__enter__");

    if (!method)

        return NULL;

    result = PyObject_Call(method, args, kwds);

    Py_DECREF(method);

    return result;

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_exit(

        ProxyObject *self, PyObject *args, PyObject *kwds)

{

    PyObject *method = NULL;

    PyObject *result = NULL;

    Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

    method = PyObject_GetAttrString(self->wrapped, "__exit__");

    if (!method)

        return NULL;

    result = PyObject_Call(method, args, kwds);

    Py_DECREF(method);

    return result;

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_bytes(

        ProxyObject *self, PyObject *args)

{

    Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

    return PyObject_Bytes(self->wrapped);

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_reversed(

        ProxyObject *self, PyObject *args)

{

    Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

    return PyObject_CallFunctionObjArgs((PyObject *)&PyReversed_Type,

            self->wrapped, NULL);

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_reduce(

        ProxyObject *self, PyObject *args)

{

    Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

    return Py_BuildValue("(O(O))", identity_ref, self->wrapped);

}

/* ------------------------------------------------------------------------- */

#if PY_MAJOR_VERSION >= 3

static PyObject *Proxy_round(

        ProxyObject *self, PyObject *args)

{

    PyObject *module = NULL;

    PyObject *dict = NULL;

    PyObject *round = NULL;

    PyObject *result = NULL;

    Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

    module = PyImport_ImportModule("builtins");

    if (!module)

        return NULL;

    dict = PyModule_GetDict(module);

    round = PyDict_GetItemString(dict, "round");

    if (!round) {

        Py_DECREF(module);

        return NULL;

    }

    Py_INCREF(round);

    Py_DECREF(module);

    result = PyObject_CallFunctionObjArgs(round, self->wrapped, NULL);

    Py_DECREF(round);

    return result;

}

#endif

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_get_name(

        ProxyObject *self)

{

    Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

    return PyObject_GetAttrString(self->wrapped, "__name__");

}

/* ------------------------------------------------------------------------- */

static int Proxy_set_name(ProxyObject *self,

        PyObject *value)

{

    Proxy__ENSURE_WRAPPED_OR_RETURN_MINUS1(self);

    return PyObject_SetAttrString(self->wrapped, "__name__", value);

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_get_qualname(

        ProxyObject *self)

{

    Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

    return PyObject_GetAttrString(self->wrapped, "__qualname__");

}

/* ------------------------------------------------------------------------- */

static int Proxy_set_qualname(ProxyObject *self,

        PyObject *value)

{

    Proxy__ENSURE_WRAPPED_OR_RETURN_MINUS1(self);

    return PyObject_SetAttrString(self->wrapped, "__qualname__", value);

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_get_module(

        ProxyObject *self)

{

    Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

    return PyObject_GetAttrString(self->wrapped, "__module__");

}

/* ------------------------------------------------------------------------- */

static int Proxy_set_module(ProxyObject *self,

        PyObject *value)

{

    Proxy__ENSURE_WRAPPED_OR_RETURN_MINUS1(self);

    if (PyObject_SetAttrString(self->wrapped, "__module__", value) == -1)

        return -1;

    return PyDict_SetItemString(self->dict, "__module__", value);

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_get_doc(

        ProxyObject *self)

{

    Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

    return PyObject_GetAttrString(self->wrapped, "__doc__");

}

/* ------------------------------------------------------------------------- */

static int Proxy_set_doc(ProxyObject *self,

        PyObject *value)

{

    Proxy__ENSURE_WRAPPED_OR_RETURN_MINUS1(self);

    if (PyObject_SetAttrString(self->wrapped, "__doc__", value) == -1)

        return -1;

    return PyDict_SetItemString(self->dict, "__doc__", value);

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_get_class(

        ProxyObject *self)

{

    Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

    return PyObject_GetAttrString(self->wrapped, "__class__");

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_get_annotations(

        ProxyObject *self)

{

    Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

    return PyObject_GetAttrString(self->wrapped, "__annotations__");

}

/* ------------------------------------------------------------------------- */

static int Proxy_set_annotations(ProxyObject *self,

        PyObject *value)

{

    Proxy__ENSURE_WRAPPED_OR_RETURN_MINUS1(self);

    return PyObject_SetAttrString(self->wrapped, "__annotations__", value);

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_get_wrapped(

        ProxyObject *self)

{

    Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

    Py_INCREF(self->wrapped);

    return self->wrapped;

}

/* ------------------------------------------------------------------------- */

static int Proxy_set_wrapped(ProxyObject *self,

        PyObject *value)

{

    if (value) Py_INCREF(value);

    Py_XDECREF(self->wrapped);

    self->wrapped = value;

    return 0;

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_get_factory(

        ProxyObject *self)

{

    Py_INCREF(self->factory);

    return self->factory;

}

/* ------------------------------------------------------------------------- */

static int Proxy_set_factory(ProxyObject *self,

        PyObject *value)

{

    if (value) Py_INCREF(value);

    Py_XDECREF(self->factory);

    self->factory = value;

    return 0;

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_getattro(

        ProxyObject *self, PyObject *name)

{

    PyObject *object = NULL;

    PyObject *result = NULL;

    static PyObject *getattr_str = NULL;

    object = PyObject_GenericGetAttr((PyObject *)self, name);

    if (object)

        return object;

    PyErr_Clear();

    if (!getattr_str) {

#if PY_MAJOR_VERSION >= 3

        getattr_str = PyUnicode_InternFromString("__getattr__");

#else

        getattr_str = PyString_InternFromString("__getattr__");

#endif

    }

    object = PyObject_GenericGetAttr((PyObject *)self, getattr_str);

    if (!object)

        return NULL;

    result = PyObject_CallFunctionObjArgs(object, name, NULL);

    Py_DECREF(object);

    return result;

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_getattr(

        ProxyObject *self, PyObject *args)

{

    PyObject *name = NULL;

#if PY_MAJOR_VERSION >= 3

    if (!PyArg_ParseTuple(args, "U:__getattr__", &name))

        return NULL;

#else

    if (!PyArg_ParseTuple(args, "S:__getattr__", &name))

        return NULL;

#endif

    Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

    return PyObject_GetAttr(self->wrapped, name);

}

/* ------------------------------------------------------------------------- */

static int Proxy_setattro(

        ProxyObject *self, PyObject *name, PyObject *value)

{

    if (PyObject_HasAttr((PyObject *)Py_TYPE(self), name))

        return PyObject_GenericSetAttr((PyObject *)self, name, value);

    Proxy__ENSURE_WRAPPED_OR_RETURN_MINUS1(self);

    return PyObject_SetAttr(self->wrapped, name, value);

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_richcompare(ProxyObject *self,

        PyObject *other, int opcode)

{

    Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

    return PyObject_RichCompare(self->wrapped, other, opcode);

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_iter(ProxyObject *self)

{

    Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

    return PyObject_GetIter(self->wrapped);

}

/* ------------------------------------------------------------------------- */

static PyObject *Proxy_call(

        ProxyObject *self, PyObject *args, PyObject *kwds)

{

    Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

    return PyObject_Call(self->wrapped, args, kwds);

}

/* ------------------------------------------------------------------------- */;

static PyNumberMethods Proxy_as_number = {

    (binaryfunc)Proxy_add,                  /*nb_add*/

    (binaryfunc)Proxy_subtract,             /*nb_subtract*/

    (binaryfunc)Proxy_multiply,             /*nb_multiply*/

#if PY_MAJOR_VERSION < 3

    (binaryfunc)Proxy_divide,               /*nb_divide*/

#endif

    (binaryfunc)Proxy_remainder,            /*nb_remainder*/

    (binaryfunc)Proxy_divmod,               /*nb_divmod*/

    (ternaryfunc)Proxy_power,               /*nb_power*/

    (unaryfunc)Proxy_negative,              /*nb_negative*/

    (unaryfunc)Proxy_positive,              /*nb_positive*/

    (unaryfunc)Proxy_absolute,              /*nb_absolute*/

    (inquiry)Proxy_bool,                    /*nb_nonzero/nb_bool*/

    (unaryfunc)Proxy_invert,                /*nb_invert*/

    (binaryfunc)Proxy_lshift,               /*nb_lshift*/

    (binaryfunc)Proxy_rshift,               /*nb_rshift*/

    (binaryfunc)Proxy_and,                  /*nb_and*/

    (binaryfunc)Proxy_xor,                  /*nb_xor*/

    (binaryfunc)Proxy_or,                   /*nb_or*/

#if PY_MAJOR_VERSION < 3

    0,                                      /*nb_coerce*/

#endif

#if PY_MAJOR_VERSION < 3

    (unaryfunc)Proxy_int,                   /*nb_int*/

    (unaryfunc)Proxy_long,                  /*nb_long*/

#else

    (unaryfunc)Proxy_long,                  /*nb_int*/

    0,                                      /*nb_long/nb_reserved*/

#endif

    (unaryfunc)Proxy_float,                 /*nb_float*/

#if PY_MAJOR_VERSION < 3

    (unaryfunc)Proxy_oct,                   /*nb_oct*/

    (unaryfunc)Proxy_hex,                   /*nb_hex*/

#endif

    (binaryfunc)Proxy_inplace_add,          /*nb_inplace_add*/

    (binaryfunc)Proxy_inplace_subtract,     /*nb_inplace_subtract*/

    (binaryfunc)Proxy_inplace_multiply,     /*nb_inplace_multiply*/

#if PY_MAJOR_VERSION < 3

    (binaryfunc)Proxy_inplace_divide,       /*nb_inplace_divide*/

#endif

    (binaryfunc)Proxy_inplace_remainder,    /*nb_inplace_remainder*/

    (ternaryfunc)Proxy_inplace_power,       /*nb_inplace_power*/

    (binaryfunc)Proxy_inplace_lshift,       /*nb_inplace_lshift*/

    (binaryfunc)Proxy_inplace_rshift,       /*nb_inplace_rshift*/