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

#include "Python.h"

#include "structmember.h"

#define Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(object) \

if (PyObject_TypeCheck(object, &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;

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

typedef struct {

PyObject_HEAD

PyObject *dict;

PyObject *wrapped;

PyObject *factory;

} ProxyObject;

PyTypeObject Proxy_Type;

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

static PyObject *identity_ref = NULL;

static PyObject *await_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 (self->wrapped) {

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 {

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

Py_TYPE(self)->tp_name, self,

self->factory);

}

}

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

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_fspath(ProxyObject *self)

{

PyObject *method = NULL;

PyObject *fspath = NULL;

Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

if (PyUnicode_Check(self->wrapped) || PyBytes_Check(self->wrapped)) {

Py_INCREF(self->wrapped);

return self->wrapped;

}

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

if (!method) {

PyErr_Clear();

Py_INCREF(self->wrapped);

return self->wrapped;

}

fspath = PyObject_CallFunctionObjArgs(method, NULL);

Py_DECREF(method);

return fspath;

}

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

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);

}

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

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

{

Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(o1);

Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(o2);

return PyNumber_MatrixMultiply(o1, o2);

}

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

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);

}

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

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);

}

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

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;

}

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

static PyObject *Proxy_inplace_matrix_multiply(

ProxyObject *self, PyObject *other)

{

PyObject *object = NULL;

Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

Proxy__WRAPPED_REPLACE_OR_RETURN_NULL(other);

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

if (!object)

return NULL;

Py_DECREF(self->wrapped);

self->wrapped = object;

Py_INCREF(self);

return (PyObject *)self;

}

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

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 *method = NULL;

PyObject *result = NULL;

Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

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

if (!method)

return NULL;

result = PyObject_CallObject(method, NULL);

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);

}

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

static PyObject *Proxy_round(ProxyObject *self, PyObject *args, PyObject *kwds)

{

PyObject *module = NULL;

PyObject *round = NULL;

PyObject *ndigits = NULL;

PyObject *result = NULL;

char *const kwlist[] = { "ndigits", NULL };

Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);

if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O:ObjectProxy", kwlist, &ndigits)) {

return NULL;

}

module = PyImport_ImportModule("builtins");

if (!module)

return NULL;

round = PyObject_GetAttrString(module, "round");

if (!round) {

Py_DECREF(module);

return NULL;

}

Py_INCREF(round);

Py_DECREF(module);

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

Py_DECREF(round);

return result;

}

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

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_resolved(

ProxyObject *self)

{