/* ------------------------------------------------------------------------- */ #include "Python.h" #include "structmember.h" #ifndef PyVarObject_HEAD_INIT #define PyVarObject_HEAD_INIT(type, size) PyObject_HEAD_INIT(type) size, #endif /* ------------------------------------------------------------------------- */ typedef struct { PyObject_HEAD PyObject *dict; PyObject *wrapped; PyObject *weakreflist; } WraptObjectProxyObject; PyTypeObject WraptObjectProxy_Type; PyTypeObject WraptCallableObjectProxy_Type; typedef struct { WraptObjectProxyObject object_proxy; PyObject *args; PyObject *kwargs; } WraptPartialCallableObjectProxyObject; PyTypeObject WraptPartialCallableObjectProxy_Type; typedef struct { WraptObjectProxyObject object_proxy; PyObject *instance; PyObject *wrapper; PyObject *enabled; PyObject *binding; PyObject *parent; PyObject *owner; } WraptFunctionWrapperObject; PyTypeObject WraptFunctionWrapperBase_Type; PyTypeObject WraptBoundFunctionWrapper_Type; PyTypeObject WraptFunctionWrapper_Type; /* ------------------------------------------------------------------------- */ static int raise_uninitialized_wrapper_error(WraptObjectProxyObject *object) { // Before raising an exception we need to first check whether this is a lazy // proxy object and attempt to intialize the wrapped object using the supplied // callback if so. If the callback is not present then we can proceed to raise // the exception, but if the callback is present and returns a value, we set // that as the wrapped object and continue and return without raising an error. static PyObject *wrapped_str = NULL; static PyObject *wrapped_factory_str = NULL; static PyObject *wrapped_get_str = NULL; PyObject *callback = NULL; PyObject *value = NULL; if (!wrapped_str) { wrapped_str = PyUnicode_InternFromString("__wrapped__"); wrapped_factory_str = PyUnicode_InternFromString("__wrapped_factory__"); wrapped_get_str = PyUnicode_InternFromString("__wrapped_get__"); } // Note that we use existance of __wrapped_factory__ to gate whether we can // attempt to initialize the wrapped object lazily, but it is __wrapped_get__ // that we actually call to do the initialization. This is so that we can // handle multithreading correctly by having __wrapped_get__ use a lock to // protect against multiple threads trying to initialize the wrapped object // at the same time. callback = PyObject_GenericGetAttr((PyObject *)object, wrapped_factory_str); if (callback) { if (callback != Py_None) { Py_DECREF(callback); callback = PyObject_GenericGetAttr((PyObject *)object, wrapped_get_str); if (!callback) return -1; value = PyObject_CallObject(callback, NULL); Py_DECREF(callback); if (value) { // We use setattr so that special dunder methods will be properly set. if (PyObject_SetAttr((PyObject *)object, wrapped_str, value) == -1) { Py_DECREF(value); return -1; } Py_DECREF(value); return 0; } else { return -1; } } else { Py_DECREF(callback); } } else PyErr_Clear(); // We need to reach into the wrapt.wrappers module to get the exception // class because the exception we need to raise needs to inherit from both // ValueError and AttributeError and we can't do that in C code using the // built in exception classes, or at least not easily or safely. PyObject *wrapt_wrappers_module = NULL; PyObject *wrapper_not_initialized_error = NULL; // Import the wrapt.wrappers module and get the exception class. // We do this fresh each time to be safe with multiple sub-interpreters. wrapt_wrappers_module = PyImport_ImportModule("wrapt.wrappers"); if (!wrapt_wrappers_module) { // Fallback to ValueError if import fails. PyErr_SetString(PyExc_ValueError, "wrapper has not been initialized"); return -1; } wrapper_not_initialized_error = PyObject_GetAttrString( wrapt_wrappers_module, "WrapperNotInitializedError"); if (!wrapper_not_initialized_error) { // Fallback to ValueError if attribute lookup fails. Py_DECREF(wrapt_wrappers_module); PyErr_SetString(PyExc_ValueError, "wrapper has not been initialized"); return -1; } // Raise the custom exception. PyErr_SetString(wrapper_not_initialized_error, "wrapper has not been initialized"); // Clean up references. Py_DECREF(wrapper_not_initialized_error); Py_DECREF(wrapt_wrappers_module); return -1; } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { WraptObjectProxyObject *self; self = (WraptObjectProxyObject *)type->tp_alloc(type, 0); if (!self) return NULL; self->dict = PyDict_New(); self->wrapped = NULL; self->weakreflist = NULL; return (PyObject *)self; } /* ------------------------------------------------------------------------- */ static int WraptObjectProxy_raw_init(WraptObjectProxyObject *self, PyObject *wrapped) { static PyObject *module_str = NULL; static PyObject *doc_str = NULL; static PyObject *wrapped_factory_str = NULL; PyObject *object = NULL; // If wrapped is Py_None and we have a __wrapped_factory__ attribute // then we defer initialization of the wrapped object until it is first needed. if (!wrapped_factory_str) { wrapped_factory_str = PyUnicode_InternFromString("__wrapped_factory__"); } if (wrapped == Py_None) { PyObject *callback = NULL; callback = PyObject_GenericGetAttr((PyObject *)self, wrapped_factory_str); if (callback) { if (callback != Py_None) { Py_DECREF(callback); return 0; } else { Py_DECREF(callback); } } else PyErr_Clear(); } Py_INCREF(wrapped); Py_XDECREF(self->wrapped); self->wrapped = wrapped; if (!module_str) { module_str = PyUnicode_InternFromString("__module__"); } if (!doc_str) { doc_str = PyUnicode_InternFromString("__doc__"); } object = PyObject_GetAttr(wrapped, module_str); if (object) { if (PyDict_SetItem(self->dict, module_str, object) == -1) { Py_DECREF(object); return -1; } Py_DECREF(object); } else PyErr_Clear(); object = PyObject_GetAttr(wrapped, doc_str); if (object) { if (PyDict_SetItem(self->dict, doc_str, object) == -1) { Py_DECREF(object); return -1; } Py_DECREF(object); } else PyErr_Clear(); return 0; } /* ------------------------------------------------------------------------- */ static int WraptObjectProxy_init(WraptObjectProxyObject *self, PyObject *args, PyObject *kwds) { PyObject *wrapped = NULL; char *const kwlist[] = {"wrapped", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O:ObjectProxy", kwlist, &wrapped)) { return -1; } return WraptObjectProxy_raw_init(self, wrapped); } /* ------------------------------------------------------------------------- */ static int WraptObjectProxy_traverse(WraptObjectProxyObject *self, visitproc visit, void *arg) { Py_VISIT(self->dict); Py_VISIT(self->wrapped); return 0; } /* ------------------------------------------------------------------------- */ static int WraptObjectProxy_clear(WraptObjectProxyObject *self) { Py_CLEAR(self->dict); Py_CLEAR(self->wrapped); return 0; } /* ------------------------------------------------------------------------- */ static void WraptObjectProxy_dealloc(WraptObjectProxyObject *self) { PyObject_GC_UnTrack(self); if (self->weakreflist != NULL) PyObject_ClearWeakRefs((PyObject *)self); WraptObjectProxy_clear(self); Py_TYPE(self)->tp_free(self); } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_repr(WraptObjectProxyObject *self) { if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } return PyUnicode_FromFormat("<%s at %p for %s at %p>", Py_TYPE(self)->tp_name, self, Py_TYPE(self->wrapped)->tp_name, self->wrapped); } /* ------------------------------------------------------------------------- */ static Py_hash_t WraptObjectProxy_hash(WraptObjectProxyObject *self) { if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return -1; } return PyObject_Hash(self->wrapped); } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_str(WraptObjectProxyObject *self) { if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } return PyObject_Str(self->wrapped); } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_add(PyObject *o1, PyObject *o2) { if (PyObject_IsInstance(o1, (PyObject *)&WraptObjectProxy_Type)) { if (!((WraptObjectProxyObject *)o1)->wrapped) { if (raise_uninitialized_wrapper_error((WraptObjectProxyObject *)o1) == -1) return NULL; } o1 = ((WraptObjectProxyObject *)o1)->wrapped; } if (PyObject_IsInstance(o2, (PyObject *)&WraptObjectProxy_Type)) { if (!((WraptObjectProxyObject *)o2)->wrapped) { if (raise_uninitialized_wrapper_error((WraptObjectProxyObject *)o2) == -1) return NULL; } o2 = ((WraptObjectProxyObject *)o2)->wrapped; } return PyNumber_Add(o1, o2); } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_subtract(PyObject *o1, PyObject *o2) { if (PyObject_IsInstance(o1, (PyObject *)&WraptObjectProxy_Type)) { if (!((WraptObjectProxyObject *)o1)->wrapped) { if (raise_uninitialized_wrapper_error((WraptObjectProxyObject *)o1) == -1) return NULL; } o1 = ((WraptObjectProxyObject *)o1)->wrapped; } if (PyObject_IsInstance(o2, (PyObject *)&WraptObjectProxy_Type)) { if (!((WraptObjectProxyObject *)o2)->wrapped) { if (raise_uninitialized_wrapper_error((WraptObjectProxyObject *)o2) == -1) return NULL; } o2 = ((WraptObjectProxyObject *)o2)->wrapped; } return PyNumber_Subtract(o1, o2); } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_multiply(PyObject *o1, PyObject *o2) { if (PyObject_IsInstance(o1, (PyObject *)&WraptObjectProxy_Type)) { if (!((WraptObjectProxyObject *)o1)->wrapped) { if (raise_uninitialized_wrapper_error((WraptObjectProxyObject *)o1) == -1) return NULL; } o1 = ((WraptObjectProxyObject *)o1)->wrapped; } if (PyObject_IsInstance(o2, (PyObject *)&WraptObjectProxy_Type)) { if (!((WraptObjectProxyObject *)o2)->wrapped) { if (raise_uninitialized_wrapper_error((WraptObjectProxyObject *)o2) == -1) return NULL; } o2 = ((WraptObjectProxyObject *)o2)->wrapped; } return PyNumber_Multiply(o1, o2); } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_remainder(PyObject *o1, PyObject *o2) { if (PyObject_IsInstance(o1, (PyObject *)&WraptObjectProxy_Type)) { if (!((WraptObjectProxyObject *)o1)->wrapped) { if (raise_uninitialized_wrapper_error((WraptObjectProxyObject *)o1) == -1) return NULL; } o1 = ((WraptObjectProxyObject *)o1)->wrapped; } if (PyObject_IsInstance(o2, (PyObject *)&WraptObjectProxy_Type)) { if (!((WraptObjectProxyObject *)o2)->wrapped) { if (raise_uninitialized_wrapper_error((WraptObjectProxyObject *)o2) == -1) return NULL; } o2 = ((WraptObjectProxyObject *)o2)->wrapped; } return PyNumber_Remainder(o1, o2); } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_divmod(PyObject *o1, PyObject *o2) { if (PyObject_IsInstance(o1, (PyObject *)&WraptObjectProxy_Type)) { if (!((WraptObjectProxyObject *)o1)->wrapped) { if (raise_uninitialized_wrapper_error((WraptObjectProxyObject *)o1) == -1) return NULL; } o1 = ((WraptObjectProxyObject *)o1)->wrapped; } if (PyObject_IsInstance(o2, (PyObject *)&WraptObjectProxy_Type)) { if (!((WraptObjectProxyObject *)o2)->wrapped) { if (raise_uninitialized_wrapper_error((WraptObjectProxyObject *)o2) == -1) return NULL; } o2 = ((WraptObjectProxyObject *)o2)->wrapped; } return PyNumber_Divmod(o1, o2); } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_power(PyObject *o1, PyObject *o2, PyObject *modulo) { if (PyObject_IsInstance(o1, (PyObject *)&WraptObjectProxy_Type)) { if (!((WraptObjectProxyObject *)o1)->wrapped) { if (raise_uninitialized_wrapper_error((WraptObjectProxyObject *)o1) == -1) return NULL; } o1 = ((WraptObjectProxyObject *)o1)->wrapped; } if (PyObject_IsInstance(o2, (PyObject *)&WraptObjectProxy_Type)) { if (!((WraptObjectProxyObject *)o2)->wrapped) { if (raise_uninitialized_wrapper_error((WraptObjectProxyObject *)o2) == -1) return NULL; } o2 = ((WraptObjectProxyObject *)o2)->wrapped; } return PyNumber_Power(o1, o2, modulo); } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_negative(WraptObjectProxyObject *self) { if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } return PyNumber_Negative(self->wrapped); } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_positive(WraptObjectProxyObject *self) { if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } return PyNumber_Positive(self->wrapped); } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_absolute(WraptObjectProxyObject *self) { if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } return PyNumber_Absolute(self->wrapped); } /* ------------------------------------------------------------------------- */ static int WraptObjectProxy_bool(WraptObjectProxyObject *self) { if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return -1; } return PyObject_IsTrue(self->wrapped); } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_invert(WraptObjectProxyObject *self) { if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } return PyNumber_Invert(self->wrapped); } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_lshift(PyObject *o1, PyObject *o2) { if (PyObject_IsInstance(o1, (PyObject *)&WraptObjectProxy_Type)) { if (!((WraptObjectProxyObject *)o1)->wrapped) { if (raise_uninitialized_wrapper_error((WraptObjectProxyObject *)o1) == -1) return NULL; } o1 = ((WraptObjectProxyObject *)o1)->wrapped; } if (PyObject_IsInstance(o2, (PyObject *)&WraptObjectProxy_Type)) { if (!((WraptObjectProxyObject *)o2)->wrapped) { if (raise_uninitialized_wrapper_error((WraptObjectProxyObject *)o2) == -1) return NULL; } o2 = ((WraptObjectProxyObject *)o2)->wrapped; } return PyNumber_Lshift(o1, o2); } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_rshift(PyObject *o1, PyObject *o2) { if (PyObject_IsInstance(o1, (PyObject *)&WraptObjectProxy_Type)) { if (!((WraptObjectProxyObject *)o1)->wrapped) { if (raise_uninitialized_wrapper_error((WraptObjectProxyObject *)o1) == -1) return NULL; } o1 = ((WraptObjectProxyObject *)o1)->wrapped; } if (PyObject_IsInstance(o2, (PyObject *)&WraptObjectProxy_Type)) { if (!((WraptObjectProxyObject *)o2)->wrapped) { if (raise_uninitialized_wrapper_error((WraptObjectProxyObject *)o2) == -1) return NULL; } o2 = ((WraptObjectProxyObject *)o2)->wrapped; } return PyNumber_Rshift(o1, o2); } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_and(PyObject *o1, PyObject *o2) { if (PyObject_IsInstance(o1, (PyObject *)&WraptObjectProxy_Type)) { if (!((WraptObjectProxyObject *)o1)->wrapped) { if (raise_uninitialized_wrapper_error((WraptObjectProxyObject *)o1) == -1) return NULL; } o1 = ((WraptObjectProxyObject *)o1)->wrapped; } if (PyObject_IsInstance(o2, (PyObject *)&WraptObjectProxy_Type)) { if (!((WraptObjectProxyObject *)o2)->wrapped) { if (raise_uninitialized_wrapper_error((WraptObjectProxyObject *)o2) == -1) return NULL; } o2 = ((WraptObjectProxyObject *)o2)->wrapped; } return PyNumber_And(o1, o2); } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_xor(PyObject *o1, PyObject *o2) { if (PyObject_IsInstance(o1, (PyObject *)&WraptObjectProxy_Type)) { if (!((WraptObjectProxyObject *)o1)->wrapped) { if (raise_uninitialized_wrapper_error((WraptObjectProxyObject *)o1) == -1) return NULL; } o1 = ((WraptObjectProxyObject *)o1)->wrapped; } if (PyObject_IsInstance(o2, (PyObject *)&WraptObjectProxy_Type)) { if (!((WraptObjectProxyObject *)o2)->wrapped) { if (raise_uninitialized_wrapper_error((WraptObjectProxyObject *)o2) == -1) return NULL; } o2 = ((WraptObjectProxyObject *)o2)->wrapped; } return PyNumber_Xor(o1, o2); } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_or(PyObject *o1, PyObject *o2) { if (PyObject_IsInstance(o1, (PyObject *)&WraptObjectProxy_Type)) { if (!((WraptObjectProxyObject *)o1)->wrapped) { if (raise_uninitialized_wrapper_error((WraptObjectProxyObject *)o1) == -1) return NULL; } o1 = ((WraptObjectProxyObject *)o1)->wrapped; } if (PyObject_IsInstance(o2, (PyObject *)&WraptObjectProxy_Type)) { if (!((WraptObjectProxyObject *)o2)->wrapped) { if (raise_uninitialized_wrapper_error((WraptObjectProxyObject *)o2) == -1) return NULL; } o2 = ((WraptObjectProxyObject *)o2)->wrapped; } return PyNumber_Or(o1, o2); } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_long(WraptObjectProxyObject *self) { if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } return PyNumber_Long(self->wrapped); } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_float(WraptObjectProxyObject *self) { if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } return PyNumber_Float(self->wrapped); } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_inplace_add(WraptObjectProxyObject *self, PyObject *other) { PyObject *object = NULL; if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } if (PyObject_IsInstance(other, (PyObject *)&WraptObjectProxy_Type)) other = ((WraptObjectProxyObject *)other)->wrapped; if (PyObject_HasAttrString(self->wrapped, "__iadd__")) { object = PyNumber_InPlaceAdd(self->wrapped, other); if (!object) return NULL; Py_DECREF(self->wrapped); self->wrapped = object; Py_INCREF(self); return (PyObject *)self; } else { PyObject *result = PyNumber_Add(self->wrapped, other); if (!result) return NULL; PyObject *proxy_type = PyObject_GetAttrString((PyObject *)self, "__object_proxy__"); if (!proxy_type) { Py_DECREF(proxy_type); return NULL; } PyObject *proxy_args = PyTuple_Pack(1, result); Py_DECREF(result); if (!proxy_args) { Py_DECREF(proxy_type); return NULL; } PyObject *proxy_instance = PyObject_Call(proxy_type, proxy_args, NULL); Py_DECREF(proxy_type); Py_DECREF(proxy_args); return proxy_instance; } } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_inplace_subtract(WraptObjectProxyObject *self, PyObject *other) { PyObject *object = NULL; if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } if (PyObject_IsInstance(other, (PyObject *)&WraptObjectProxy_Type)) other = ((WraptObjectProxyObject *)other)->wrapped; if (PyObject_HasAttrString(self->wrapped, "__isub__")) { object = PyNumber_InPlaceSubtract(self->wrapped, other); if (!object) return NULL; Py_DECREF(self->wrapped); self->wrapped = object; Py_INCREF(self); return (PyObject *)self; } else { PyObject *result = PyNumber_Subtract(self->wrapped, other); if (!result) return NULL; PyObject *proxy_type = PyObject_GetAttrString((PyObject *)self, "__object_proxy__"); if (!proxy_type) { Py_DECREF(proxy_type); return NULL; } PyObject *proxy_args = PyTuple_Pack(1, result); Py_DECREF(result); if (!proxy_args) { Py_DECREF(proxy_type); return NULL; } PyObject *proxy_instance = PyObject_Call(proxy_type, proxy_args, NULL); Py_DECREF(proxy_type); Py_DECREF(proxy_args); return proxy_instance; } } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_inplace_multiply(WraptObjectProxyObject *self, PyObject *other) { PyObject *object = NULL; if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } if (PyObject_IsInstance(other, (PyObject *)&WraptObjectProxy_Type)) other = ((WraptObjectProxyObject *)other)->wrapped; if (PyObject_HasAttrString(self->wrapped, "__imul__")) { object = PyNumber_InPlaceMultiply(self->wrapped, other); if (!object) return NULL; Py_DECREF(self->wrapped); self->wrapped = object; Py_INCREF(self); return (PyObject *)self; } else { PyObject *result = PyNumber_Multiply(self->wrapped, other); if (!result) return NULL; PyObject *proxy_type = PyObject_GetAttrString((PyObject *)self, "__object_proxy__"); if (!proxy_type) { Py_DECREF(proxy_type); return NULL; } PyObject *proxy_args = PyTuple_Pack(1, result); Py_DECREF(result); if (!proxy_args) { Py_DECREF(proxy_type); return NULL; } PyObject *proxy_instance = PyObject_Call(proxy_type, proxy_args, NULL); Py_DECREF(proxy_type); Py_DECREF(proxy_args); return proxy_instance; } } /* ------------------------------------------------------------------------- */ static PyObject * WraptObjectProxy_inplace_remainder(WraptObjectProxyObject *self, PyObject *other) { PyObject *object = NULL; if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } if (PyObject_IsInstance(other, (PyObject *)&WraptObjectProxy_Type)) other = ((WraptObjectProxyObject *)other)->wrapped; if (PyObject_HasAttrString(self->wrapped, "__imod__")) { object = PyNumber_InPlaceRemainder(self->wrapped, other); if (!object) return NULL; Py_DECREF(self->wrapped); self->wrapped = object; Py_INCREF(self); return (PyObject *)self; } else { PyObject *result = PyNumber_Remainder(self->wrapped, other); if (!result) return NULL; PyObject *proxy_type = PyObject_GetAttrString((PyObject *)self, "__object_proxy__"); if (!proxy_type) { Py_DECREF(proxy_type); return NULL; } PyObject *proxy_args = PyTuple_Pack(1, result); Py_DECREF(result); if (!proxy_args) { Py_DECREF(proxy_type); return NULL; } PyObject *proxy_instance = PyObject_Call(proxy_type, proxy_args, NULL); Py_DECREF(proxy_type); Py_DECREF(proxy_args); return proxy_instance; } } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_inplace_power(WraptObjectProxyObject *self, PyObject *other, PyObject *modulo) { PyObject *object = NULL; if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } if (PyObject_IsInstance(other, (PyObject *)&WraptObjectProxy_Type)) other = ((WraptObjectProxyObject *)other)->wrapped; if (PyObject_HasAttrString(self->wrapped, "__ipow__")) { object = PyNumber_InPlacePower(self->wrapped, other, modulo); if (!object) return NULL; Py_DECREF(self->wrapped); self->wrapped = object; Py_INCREF(self); return (PyObject *)self; } else { PyObject *result = PyNumber_Power(self->wrapped, other, modulo); if (!result) return NULL; PyObject *proxy_type = PyObject_GetAttrString((PyObject *)self, "__object_proxy__"); if (!proxy_type) { Py_DECREF(proxy_type); return NULL; } PyObject *proxy_args = PyTuple_Pack(1, result); Py_DECREF(result); if (!proxy_args) { Py_DECREF(proxy_type); return NULL; } PyObject *proxy_instance = PyObject_Call(proxy_type, proxy_args, NULL); Py_DECREF(proxy_type); Py_DECREF(proxy_args); return proxy_instance; } } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_inplace_lshift(WraptObjectProxyObject *self, PyObject *other) { PyObject *object = NULL; if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } if (PyObject_IsInstance(other, (PyObject *)&WraptObjectProxy_Type)) other = ((WraptObjectProxyObject *)other)->wrapped; if (PyObject_HasAttrString(self->wrapped, "__ilshift__")) { object = PyNumber_InPlaceLshift(self->wrapped, other); if (!object) return NULL; Py_DECREF(self->wrapped); self->wrapped = object; Py_INCREF(self); return (PyObject *)self; } else { PyObject *result = PyNumber_Lshift(self->wrapped, other); if (!result) return NULL; PyObject *proxy_type = PyObject_GetAttrString((PyObject *)self, "__object_proxy__"); if (!proxy_type) { Py_DECREF(proxy_type); return NULL; } PyObject *proxy_args = PyTuple_Pack(1, result); Py_DECREF(result); if (!proxy_args) { Py_DECREF(proxy_type); return NULL; } PyObject *proxy_instance = PyObject_Call(proxy_type, proxy_args, NULL); Py_DECREF(proxy_type); Py_DECREF(proxy_args); return proxy_instance; } } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_inplace_rshift(WraptObjectProxyObject *self, PyObject *other) { PyObject *object = NULL; if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } if (PyObject_IsInstance(other, (PyObject *)&WraptObjectProxy_Type)) other = ((WraptObjectProxyObject *)other)->wrapped; if (PyObject_HasAttrString(self->wrapped, "__irshift__")) { object = PyNumber_InPlaceRshift(self->wrapped, other); if (!object) return NULL; Py_DECREF(self->wrapped); self->wrapped = object; Py_INCREF(self); return (PyObject *)self; } else { PyObject *result = PyNumber_Rshift(self->wrapped, other); if (!result) return NULL; PyObject *proxy_type = PyObject_GetAttrString((PyObject *)self, "__object_proxy__"); if (!proxy_type) { Py_DECREF(proxy_type); return NULL; } PyObject *proxy_args = PyTuple_Pack(1, result); Py_DECREF(result); if (!proxy_args) { Py_DECREF(proxy_type); return NULL; } PyObject *proxy_instance = PyObject_Call(proxy_type, proxy_args, NULL); Py_DECREF(proxy_type); Py_DECREF(proxy_args); return proxy_instance; } } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_inplace_and(WraptObjectProxyObject *self, PyObject *other) { PyObject *object = NULL; if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } if (PyObject_IsInstance(other, (PyObject *)&WraptObjectProxy_Type)) other = ((WraptObjectProxyObject *)other)->wrapped; if (PyObject_HasAttrString(self->wrapped, "__iand__")) { object = PyNumber_InPlaceAnd(self->wrapped, other); if (!object) return NULL; Py_DECREF(self->wrapped); self->wrapped = object; Py_INCREF(self); return (PyObject *)self; } else { PyObject *result = PyNumber_And(self->wrapped, other); if (!result) return NULL; PyObject *proxy_type = PyObject_GetAttrString((PyObject *)self, "__object_proxy__"); if (!proxy_type) { Py_DECREF(proxy_type); return NULL; } PyObject *proxy_args = PyTuple_Pack(1, result); Py_DECREF(result); if (!proxy_args) { Py_DECREF(proxy_type); return NULL; } PyObject *proxy_instance = PyObject_Call(proxy_type, proxy_args, NULL); Py_DECREF(proxy_type); Py_DECREF(proxy_args); return proxy_instance; } } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_inplace_xor(WraptObjectProxyObject *self, PyObject *other) { PyObject *object = NULL; if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } if (PyObject_IsInstance(other, (PyObject *)&WraptObjectProxy_Type)) other = ((WraptObjectProxyObject *)other)->wrapped; if (PyObject_HasAttrString(self->wrapped, "__ixor__")) { object = PyNumber_InPlaceXor(self->wrapped, other); if (!object) return NULL; Py_DECREF(self->wrapped); self->wrapped = object; Py_INCREF(self); return (PyObject *)self; } else { PyObject *result = PyNumber_Xor(self->wrapped, other); if (!result) return NULL; PyObject *proxy_type = PyObject_GetAttrString((PyObject *)self, "__object_proxy__"); if (!proxy_type) { Py_DECREF(proxy_type); return NULL; } PyObject *proxy_args = PyTuple_Pack(1, result); Py_DECREF(result); if (!proxy_args) { Py_DECREF(proxy_type); return NULL; } PyObject *proxy_instance = PyObject_Call(proxy_type, proxy_args, NULL); Py_DECREF(proxy_type); Py_DECREF(proxy_args); return proxy_instance; } } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_inplace_or(WraptObjectProxyObject *self, PyObject *other) { PyObject *object = NULL; if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } if (PyObject_IsInstance(other, (PyObject *)&WraptObjectProxy_Type)) other = ((WraptObjectProxyObject *)other)->wrapped; if (PyObject_HasAttrString(self->wrapped, "__ior__")) { object = PyNumber_InPlaceOr(self->wrapped, other); if (!object) return NULL; Py_DECREF(self->wrapped); self->wrapped = object; Py_INCREF(self); return (PyObject *)self; } else { PyObject *result = PyNumber_Or(self->wrapped, other); if (!result) return NULL; PyObject *proxy_type = PyObject_GetAttrString((PyObject *)self, "__object_proxy__"); if (!proxy_type) { Py_DECREF(proxy_type); return NULL; } PyObject *proxy_args = PyTuple_Pack(1, result); Py_DECREF(result); if (!proxy_args) { Py_DECREF(proxy_type); return NULL; } PyObject *proxy_instance = PyObject_Call(proxy_type, proxy_args, NULL); Py_DECREF(proxy_type); Py_DECREF(proxy_args); return proxy_instance; } } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_floor_divide(PyObject *o1, PyObject *o2) { if (PyObject_IsInstance(o1, (PyObject *)&WraptObjectProxy_Type)) { if (!((WraptObjectProxyObject *)o1)->wrapped) { if (raise_uninitialized_wrapper_error((WraptObjectProxyObject *)o1) == -1) return NULL; } o1 = ((WraptObjectProxyObject *)o1)->wrapped; } if (PyObject_IsInstance(o2, (PyObject *)&WraptObjectProxy_Type)) { if (!((WraptObjectProxyObject *)o2)->wrapped) { if (raise_uninitialized_wrapper_error((WraptObjectProxyObject *)o2) == -1) return NULL; } o2 = ((WraptObjectProxyObject *)o2)->wrapped; } return PyNumber_FloorDivide(o1, o2); } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_true_divide(PyObject *o1, PyObject *o2) { if (PyObject_IsInstance(o1, (PyObject *)&WraptObjectProxy_Type)) { if (!((WraptObjectProxyObject *)o1)->wrapped) { if (raise_uninitialized_wrapper_error((WraptObjectProxyObject *)o1) == -1) return NULL; } o1 = ((WraptObjectProxyObject *)o1)->wrapped; } if (PyObject_IsInstance(o2, (PyObject *)&WraptObjectProxy_Type)) { if (!((WraptObjectProxyObject *)o2)->wrapped) { if (raise_uninitialized_wrapper_error((WraptObjectProxyObject *)o2) == -1) return NULL; } o2 = ((WraptObjectProxyObject *)o2)->wrapped; } return PyNumber_TrueDivide(o1, o2); } /* ------------------------------------------------------------------------- */ static PyObject * WraptObjectProxy_inplace_floor_divide(WraptObjectProxyObject *self, PyObject *other) { PyObject *object = NULL; if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } if (PyObject_IsInstance(other, (PyObject *)&WraptObjectProxy_Type)) other = ((WraptObjectProxyObject *)other)->wrapped; if (PyObject_HasAttrString(self->wrapped, "__ifloordiv__")) { object = PyNumber_InPlaceFloorDivide(self->wrapped, other); if (!object) return NULL; Py_DECREF(self->wrapped); self->wrapped = object; Py_INCREF(self); return (PyObject *)self; } else { PyObject *result = PyNumber_FloorDivide(self->wrapped, other); if (!result) return NULL; PyObject *proxy_type = PyObject_GetAttrString((PyObject *)self, "__object_proxy__"); if (!proxy_type) { Py_DECREF(proxy_type); return NULL; } PyObject *proxy_args = PyTuple_Pack(1, result); Py_DECREF(result); if (!proxy_args) { Py_DECREF(proxy_type); return NULL; } PyObject *proxy_instance = PyObject_Call(proxy_type, proxy_args, NULL); Py_DECREF(proxy_type); Py_DECREF(proxy_args); return proxy_instance; } } /* ------------------------------------------------------------------------- */ static PyObject * WraptObjectProxy_inplace_true_divide(WraptObjectProxyObject *self, PyObject *other) { PyObject *object = NULL; if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } if (PyObject_IsInstance(other, (PyObject *)&WraptObjectProxy_Type)) other = ((WraptObjectProxyObject *)other)->wrapped; if (PyObject_HasAttrString(self->wrapped, "__itruediv__")) { object = PyNumber_InPlaceTrueDivide(self->wrapped, other); if (!object) return NULL; Py_DECREF(self->wrapped); self->wrapped = object; Py_INCREF(self); return (PyObject *)self; } else { PyObject *result = PyNumber_TrueDivide(self->wrapped, other); if (!result) return NULL; PyObject *proxy_type = PyObject_GetAttrString((PyObject *)self, "__object_proxy__"); if (!proxy_type) { Py_DECREF(proxy_type); return NULL; } PyObject *proxy_args = PyTuple_Pack(1, result); Py_DECREF(result); if (!proxy_args) { Py_DECREF(proxy_type); return NULL; } PyObject *proxy_instance = PyObject_Call(proxy_type, proxy_args, NULL); Py_DECREF(proxy_type); Py_DECREF(proxy_args); return proxy_instance; } } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_index(WraptObjectProxyObject *self) { if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } return PyNumber_Index(self->wrapped); } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_matrix_multiply(PyObject *o1, PyObject *o2) { if (PyObject_IsInstance(o1, (PyObject *)&WraptObjectProxy_Type)) { if (!((WraptObjectProxyObject *)o1)->wrapped) { if (raise_uninitialized_wrapper_error((WraptObjectProxyObject *)o1) == -1) return NULL; } o1 = ((WraptObjectProxyObject *)o1)->wrapped; } if (PyObject_IsInstance(o2, (PyObject *)&WraptObjectProxy_Type)) { if (!((WraptObjectProxyObject *)o2)->wrapped) { if (raise_uninitialized_wrapper_error((WraptObjectProxyObject *)o2) == -1) return NULL; } o2 = ((WraptObjectProxyObject *)o2)->wrapped; } return PyNumber_MatrixMultiply(o1, o2); } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_inplace_matrix_multiply( WraptObjectProxyObject *self, PyObject *other) { PyObject *object = NULL; if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } if (PyObject_IsInstance(other, (PyObject *)&WraptObjectProxy_Type)) other = ((WraptObjectProxyObject *)other)->wrapped; if (PyObject_HasAttrString(self->wrapped, "__imatmul__")) { object = PyNumber_InPlaceMatrixMultiply(self->wrapped, other); if (!object) return NULL; Py_DECREF(self->wrapped); self->wrapped = object; Py_INCREF(self); return (PyObject *)self; } else { PyObject *result = PyNumber_MatrixMultiply(self->wrapped, other); if (!result) return NULL; PyObject *proxy_type = PyObject_GetAttrString((PyObject *)self, "__object_proxy__"); if (!proxy_type) { Py_DECREF(proxy_type); return NULL; } PyObject *proxy_args = PyTuple_Pack(1, result); Py_DECREF(result); if (!proxy_args) { Py_DECREF(proxy_type); return NULL; } PyObject *proxy_instance = PyObject_Call(proxy_type, proxy_args, NULL); Py_DECREF(proxy_type); Py_DECREF(proxy_args); return proxy_instance; } } /* ------------------------------------------------------------------------- */ static Py_ssize_t WraptObjectProxy_length(WraptObjectProxyObject *self) { if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return -1; } return PyObject_Length(self->wrapped); } /* ------------------------------------------------------------------------- */ static int WraptObjectProxy_contains(WraptObjectProxyObject *self, PyObject *value) { if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return -1; } return PySequence_Contains(self->wrapped, value); } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_getitem(WraptObjectProxyObject *self, PyObject *key) { if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } return PyObject_GetItem(self->wrapped, key); } /* ------------------------------------------------------------------------- */ static int WraptObjectProxy_setitem(WraptObjectProxyObject *self, PyObject *key, PyObject *value) { if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return -1; } if (value == NULL) return PyObject_DelItem(self->wrapped, key); else return PyObject_SetItem(self->wrapped, key, value); } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_self_setattr(WraptObjectProxyObject *self, PyObject *args) { PyObject *name = NULL; PyObject *value = NULL; if (!PyArg_ParseTuple(args, "UO:__self_setattr__", &name, &value)) return NULL; if (PyObject_GenericSetAttr((PyObject *)self, name, value) != 0) { return NULL; } Py_INCREF(Py_None); return Py_None; } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_dir(WraptObjectProxyObject *self, PyObject *args) { if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } return PyObject_Dir(self->wrapped); } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_enter(WraptObjectProxyObject *self, PyObject *args, PyObject *kwds) { PyObject *method = NULL; PyObject *result = NULL; if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } method = PyObject_GetAttrString(self->wrapped, "__enter__"); if (!method) return NULL; result = PyObject_Call(method, args, kwds); Py_DECREF(method); return result; } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_exit(WraptObjectProxyObject *self, PyObject *args, PyObject *kwds) { PyObject *method = NULL; PyObject *result = NULL; if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } method = PyObject_GetAttrString(self->wrapped, "__exit__"); if (!method) return NULL; result = PyObject_Call(method, args, kwds); Py_DECREF(method); return result; } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_aenter(WraptObjectProxyObject *self, PyObject *args, PyObject *kwds) { PyObject *method = NULL; PyObject *result = NULL; if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } method = PyObject_GetAttrString(self->wrapped, "__aenter__"); if (!method) return NULL; result = PyObject_Call(method, args, kwds); Py_DECREF(method); return result; } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_aexit(WraptObjectProxyObject *self, PyObject *args, PyObject *kwds) { PyObject *method = NULL; PyObject *result = NULL; if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } method = PyObject_GetAttrString(self->wrapped, "__aexit__"); if (!method) return NULL; result = PyObject_Call(method, args, kwds); Py_DECREF(method); return result; } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_copy(WraptObjectProxyObject *self, PyObject *args, PyObject *kwds) { PyErr_SetString(PyExc_NotImplementedError, "object proxy must define __copy__()"); return NULL; } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_deepcopy(WraptObjectProxyObject *self, PyObject *args, PyObject *kwds) { PyErr_SetString(PyExc_NotImplementedError, "object proxy must define __deepcopy__()"); return NULL; } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_reduce(WraptObjectProxyObject *self, PyObject *args, PyObject *kwds) { PyErr_SetString(PyExc_NotImplementedError, "object proxy must define __reduce__()"); return NULL; } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_reduce_ex(WraptObjectProxyObject *self, PyObject *args, PyObject *kwds) { PyErr_SetString(PyExc_NotImplementedError, "object proxy must define __reduce_ex__()"); return NULL; } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_bytes(WraptObjectProxyObject *self, PyObject *args) { if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } return PyObject_Bytes(self->wrapped); } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_format(WraptObjectProxyObject *self, PyObject *args) { PyObject *format_spec = NULL; if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } if (!PyArg_ParseTuple(args, "|O:format", &format_spec)) return NULL; return PyObject_Format(self->wrapped, format_spec); } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_reversed(WraptObjectProxyObject *self, PyObject *args) { if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } return PyObject_CallFunctionObjArgs((PyObject *)&PyReversed_Type, self->wrapped, NULL); } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_round(WraptObjectProxyObject *self, PyObject *args, PyObject *kwds) { PyObject *ndigits = NULL; PyObject *module = NULL; PyObject *round = NULL; PyObject *result = NULL; char *const kwlist[] = {"ndigits", NULL}; if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } 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 *WraptObjectProxy_complex(WraptObjectProxyObject *self, PyObject *args) { if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } return PyObject_CallFunctionObjArgs((PyObject *)&PyComplex_Type, self->wrapped, NULL); } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_mro_entries(WraptObjectProxyObject *self, PyObject *args, PyObject *kwds) { PyObject *wrapped = NULL; PyObject *mro_entries_method = NULL; PyObject *result = NULL; int is_type = 0; if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } wrapped = self->wrapped; // Check if wrapped is a type (class). is_type = PyType_Check(wrapped); // If wrapped is not a type and has __mro_entries__, forward to it. if (!is_type) { mro_entries_method = PyObject_GetAttrString(wrapped, "__mro_entries__"); if (mro_entries_method) { // Call wrapped.__mro_entries__(bases). result = PyObject_Call(mro_entries_method, args, kwds); Py_DECREF(mro_entries_method); return result; } else { PyErr_Clear(); } } return Py_BuildValue("(O)", wrapped); } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_get_name(WraptObjectProxyObject *self) { if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } return PyObject_GetAttrString(self->wrapped, "__name__"); } /* ------------------------------------------------------------------------- */ static int WraptObjectProxy_set_name(WraptObjectProxyObject *self, PyObject *value) { if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return -1; } return PyObject_SetAttrString(self->wrapped, "__name__", value); } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_get_qualname(WraptObjectProxyObject *self) { if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } return PyObject_GetAttrString(self->wrapped, "__qualname__"); } /* ------------------------------------------------------------------------- */ static int WraptObjectProxy_set_qualname(WraptObjectProxyObject *self, PyObject *value) { if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return -1; } return PyObject_SetAttrString(self->wrapped, "__qualname__", value); } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_get_module(WraptObjectProxyObject *self) { if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } return PyObject_GetAttrString(self->wrapped, "__module__"); } /* ------------------------------------------------------------------------- */ static int WraptObjectProxy_set_module(WraptObjectProxyObject *self, PyObject *value) { if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return -1; } if (PyObject_SetAttrString(self->wrapped, "__module__", value) == -1) return -1; return PyDict_SetItemString(self->dict, "__module__", value); } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_get_doc(WraptObjectProxyObject *self) { if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } return PyObject_GetAttrString(self->wrapped, "__doc__"); } /* ------------------------------------------------------------------------- */ static int WraptObjectProxy_set_doc(WraptObjectProxyObject *self, PyObject *value) { if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return -1; } if (PyObject_SetAttrString(self->wrapped, "__doc__", value) == -1) return -1; return PyDict_SetItemString(self->dict, "__doc__", value); } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_get_class(WraptObjectProxyObject *self) { if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } return PyObject_GetAttrString(self->wrapped, "__class__"); } /* ------------------------------------------------------------------------- */ static int WraptObjectProxy_set_class(WraptObjectProxyObject *self, PyObject *value) { if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return -1; } return PyObject_SetAttrString(self->wrapped, "__class__", value); } /* ------------------------------------------------------------------------- */ static PyObject * WraptObjectProxy_get_annotations(WraptObjectProxyObject *self) { if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } return PyObject_GetAttrString(self->wrapped, "__annotations__"); } /* ------------------------------------------------------------------------- */ static int WraptObjectProxy_set_annotations(WraptObjectProxyObject *self, PyObject *value) { if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return -1; } return PyObject_SetAttrString(self->wrapped, "__annotations__", value); } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_get_wrapped(WraptObjectProxyObject *self) { if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } Py_INCREF(self->wrapped); return self->wrapped; } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_get_object_proxy(WraptObjectProxyObject *self) { Py_INCREF(&WraptObjectProxy_Type); return (PyObject *)&WraptObjectProxy_Type; } /* ------------------------------------------------------------------------- */ static int WraptObjectProxy_set_wrapped(WraptObjectProxyObject *self, PyObject *value) { static PyObject *fixups_str = NULL; PyObject *fixups = NULL; if (!value) { PyErr_SetString(PyExc_TypeError, "__wrapped__ must be an object"); return -1; } Py_INCREF(value); Py_XDECREF(self->wrapped); self->wrapped = value; if (!fixups_str) { fixups_str = PyUnicode_InternFromString("__wrapped_setattr_fixups__"); } fixups = PyObject_GetAttr((PyObject *)self, fixups_str); if (fixups) { PyObject *result = NULL; result = PyObject_CallObject(fixups, NULL); Py_DECREF(fixups); if (!result) return -1; Py_DECREF(result); } else PyErr_Clear(); return 0; } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_getattro(WraptObjectProxyObject *self, PyObject *name) { PyObject *object = NULL; PyObject *result = NULL; static PyObject *getattr_str = NULL; object = PyObject_GenericGetAttr((PyObject *)self, name); if (object) return object; if (!PyErr_ExceptionMatches(PyExc_AttributeError)) return NULL; PyErr_Clear(); if (!getattr_str) { getattr_str = PyUnicode_InternFromString("__getattr__"); } object = PyObject_GenericGetAttr((PyObject *)self, getattr_str); if (!object) return NULL; result = PyObject_CallFunctionObjArgs(object, name, NULL); Py_DECREF(object); return result; } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_getattr(WraptObjectProxyObject *self, PyObject *args) { PyObject *name = NULL; if (!PyArg_ParseTuple(args, "U:__getattr__", &name)) return NULL; if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } return PyObject_GetAttr(self->wrapped, name); } /* ------------------------------------------------------------------------- */ static int WraptObjectProxy_setattro(WraptObjectProxyObject *self, PyObject *name, PyObject *value) { static PyObject *self_str = NULL; static PyObject *startswith_str = NULL; PyObject *match = NULL; if (!startswith_str) { startswith_str = PyUnicode_InternFromString("startswith"); } if (!self_str) { self_str = PyUnicode_InternFromString("_self_"); } match = PyObject_CallMethodObjArgs(name, startswith_str, self_str, NULL); if (match == Py_True) { Py_DECREF(match); return PyObject_GenericSetAttr((PyObject *)self, name, value); } else if (!match) PyErr_Clear(); Py_XDECREF(match); if (PyObject_HasAttr((PyObject *)Py_TYPE(self), name)) return PyObject_GenericSetAttr((PyObject *)self, name, value); if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return -1; } return PyObject_SetAttr(self->wrapped, name, value); } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_richcompare(WraptObjectProxyObject *self, PyObject *other, int opcode) { if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } return PyObject_RichCompare(self->wrapped, other, opcode); } /* ------------------------------------------------------------------------- */ static PyObject *WraptObjectProxy_iter(WraptObjectProxyObject *self) { if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } return PyObject_GetIter(self->wrapped); } /* ------------------------------------------------------------------------- */ static PyNumberMethods WraptObjectProxy_as_number = { (binaryfunc)WraptObjectProxy_add, /*nb_add*/ (binaryfunc)WraptObjectProxy_subtract, /*nb_subtract*/ (binaryfunc)WraptObjectProxy_multiply, /*nb_multiply*/ (binaryfunc)WraptObjectProxy_remainder, /*nb_remainder*/ (binaryfunc)WraptObjectProxy_divmod, /*nb_divmod*/ (ternaryfunc)WraptObjectProxy_power, /*nb_power*/ (unaryfunc)WraptObjectProxy_negative, /*nb_negative*/ (unaryfunc)WraptObjectProxy_positive, /*nb_positive*/ (unaryfunc)WraptObjectProxy_absolute, /*nb_absolute*/ (inquiry)WraptObjectProxy_bool, /*nb_nonzero/nb_bool*/ (unaryfunc)WraptObjectProxy_invert, /*nb_invert*/ (binaryfunc)WraptObjectProxy_lshift, /*nb_lshift*/ (binaryfunc)WraptObjectProxy_rshift, /*nb_rshift*/ (binaryfunc)WraptObjectProxy_and, /*nb_and*/ (binaryfunc)WraptObjectProxy_xor, /*nb_xor*/ (binaryfunc)WraptObjectProxy_or, /*nb_or*/ (unaryfunc)WraptObjectProxy_long, /*nb_int*/ 0, /*nb_long/nb_reserved*/ (unaryfunc)WraptObjectProxy_float, /*nb_float*/ (binaryfunc)WraptObjectProxy_inplace_add, /*nb_inplace_add*/ (binaryfunc)WraptObjectProxy_inplace_subtract, /*nb_inplace_subtract*/ (binaryfunc)WraptObjectProxy_inplace_multiply, /*nb_inplace_multiply*/ (binaryfunc)WraptObjectProxy_inplace_remainder, /*nb_inplace_remainder*/ (ternaryfunc)WraptObjectProxy_inplace_power, /*nb_inplace_power*/ (binaryfunc)WraptObjectProxy_inplace_lshift, /*nb_inplace_lshift*/ (binaryfunc)WraptObjectProxy_inplace_rshift, /*nb_inplace_rshift*/ (binaryfunc)WraptObjectProxy_inplace_and, /*nb_inplace_and*/ (binaryfunc)WraptObjectProxy_inplace_xor, /*nb_inplace_xor*/ (binaryfunc)WraptObjectProxy_inplace_or, /*nb_inplace_or*/ (binaryfunc)WraptObjectProxy_floor_divide, /*nb_floor_divide*/ (binaryfunc)WraptObjectProxy_true_divide, /*nb_true_divide*/ (binaryfunc) WraptObjectProxy_inplace_floor_divide, /*nb_inplace_floor_divide*/ (binaryfunc)WraptObjectProxy_inplace_true_divide, /*nb_inplace_true_divide*/ (unaryfunc)WraptObjectProxy_index, /*nb_index*/ (binaryfunc)WraptObjectProxy_matrix_multiply, /*nb_matrix_multiply*/ (binaryfunc)WraptObjectProxy_inplace_matrix_multiply, /*nb_inplace_matrix_multiply*/ }; static PySequenceMethods WraptObjectProxy_as_sequence = { (lenfunc)WraptObjectProxy_length, /*sq_length*/ 0, /*sq_concat*/ 0, /*sq_repeat*/ 0, /*sq_item*/ 0, /*sq_slice*/ 0, /*sq_ass_item*/ 0, /*sq_ass_slice*/ (objobjproc)WraptObjectProxy_contains, /* sq_contains */ }; static PyMappingMethods WraptObjectProxy_as_mapping = { (lenfunc)WraptObjectProxy_length, /*mp_length*/ (binaryfunc)WraptObjectProxy_getitem, /*mp_subscript*/ (objobjargproc)WraptObjectProxy_setitem, /*mp_ass_subscript*/ }; static PyMethodDef WraptObjectProxy_methods[] = { {"__self_setattr__", (PyCFunction)WraptObjectProxy_self_setattr, METH_VARARGS, 0}, {"__dir__", (PyCFunction)WraptObjectProxy_dir, METH_NOARGS, 0}, {"__enter__", (PyCFunction)WraptObjectProxy_enter, METH_VARARGS | METH_KEYWORDS, 0}, {"__exit__", (PyCFunction)WraptObjectProxy_exit, METH_VARARGS | METH_KEYWORDS, 0}, {"__aenter__", (PyCFunction)WraptObjectProxy_aenter, METH_VARARGS | METH_KEYWORDS, 0}, {"__aexit__", (PyCFunction)WraptObjectProxy_aexit, METH_VARARGS | METH_KEYWORDS, 0}, {"__copy__", (PyCFunction)WraptObjectProxy_copy, METH_NOARGS, 0}, {"__deepcopy__", (PyCFunction)WraptObjectProxy_deepcopy, METH_VARARGS | METH_KEYWORDS, 0}, {"__reduce__", (PyCFunction)WraptObjectProxy_reduce, METH_NOARGS, 0}, {"__reduce_ex__", (PyCFunction)WraptObjectProxy_reduce_ex, METH_VARARGS | METH_KEYWORDS, 0}, {"__getattr__", (PyCFunction)WraptObjectProxy_getattr, METH_VARARGS, 0}, {"__bytes__", (PyCFunction)WraptObjectProxy_bytes, METH_NOARGS, 0}, {"__format__", (PyCFunction)WraptObjectProxy_format, METH_VARARGS, 0}, {"__reversed__", (PyCFunction)WraptObjectProxy_reversed, METH_NOARGS, 0}, {"__round__", (PyCFunction)WraptObjectProxy_round, METH_VARARGS | METH_KEYWORDS, 0}, {"__complex__", (PyCFunction)WraptObjectProxy_complex, METH_NOARGS, 0}, {"__mro_entries__", (PyCFunction)WraptObjectProxy_mro_entries, METH_VARARGS | METH_KEYWORDS, 0}, {NULL, NULL}, }; static PyGetSetDef WraptObjectProxy_getset[] = { {"__name__", (getter)WraptObjectProxy_get_name, (setter)WraptObjectProxy_set_name, 0}, {"__qualname__", (getter)WraptObjectProxy_get_qualname, (setter)WraptObjectProxy_set_qualname, 0}, {"__module__", (getter)WraptObjectProxy_get_module, (setter)WraptObjectProxy_set_module, 0}, {"__doc__", (getter)WraptObjectProxy_get_doc, (setter)WraptObjectProxy_set_doc, 0}, {"__class__", (getter)WraptObjectProxy_get_class, (setter)WraptObjectProxy_set_class, 0}, {"__annotations__", (getter)WraptObjectProxy_get_annotations, (setter)WraptObjectProxy_set_annotations, 0}, {"__wrapped__", (getter)WraptObjectProxy_get_wrapped, (setter)WraptObjectProxy_set_wrapped, 0}, {"__object_proxy__", (getter)WraptObjectProxy_get_object_proxy, 0, 0}, {NULL}, }; PyTypeObject WraptObjectProxy_Type = { PyVarObject_HEAD_INIT(NULL, 0) "ObjectProxy", /*tp_name*/ sizeof(WraptObjectProxyObject), /*tp_basicsize*/ 0, /*tp_itemsize*/ /* methods */ (destructor)WraptObjectProxy_dealloc, /*tp_dealloc*/ 0, /*tp_print*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ 0, /*tp_as_async*/ (unaryfunc)WraptObjectProxy_repr, /*tp_repr*/ &WraptObjectProxy_as_number, /*tp_as_number*/ &WraptObjectProxy_as_sequence, /*tp_as_sequence*/ &WraptObjectProxy_as_mapping, /*tp_as_mapping*/ (hashfunc)WraptObjectProxy_hash, /*tp_hash*/ 0, /*tp_call*/ (unaryfunc)WraptObjectProxy_str, /*tp_str*/ (getattrofunc)WraptObjectProxy_getattro, /*tp_getattro*/ (setattrofunc)WraptObjectProxy_setattro, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ (traverseproc)WraptObjectProxy_traverse, /*tp_traverse*/ (inquiry)WraptObjectProxy_clear, /*tp_clear*/ (richcmpfunc)WraptObjectProxy_richcompare, /*tp_richcompare*/ offsetof(WraptObjectProxyObject, weakreflist), /*tp_weaklistoffset*/ 0, /* (getiterfunc)WraptObjectProxy_iter, */ /*tp_iter*/ 0, /*tp_iternext*/ WraptObjectProxy_methods, /*tp_methods*/ 0, /*tp_members*/ WraptObjectProxy_getset, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ offsetof(WraptObjectProxyObject, dict), /*tp_dictoffset*/ (initproc)WraptObjectProxy_init, /*tp_init*/ PyType_GenericAlloc, /*tp_alloc*/ WraptObjectProxy_new, /*tp_new*/ PyObject_GC_Del, /*tp_free*/ 0, /*tp_is_gc*/ }; /* ------------------------------------------------------------------------- */ static PyObject *WraptCallableObjectProxy_call(WraptObjectProxyObject *self, PyObject *args, PyObject *kwds) { if (!self->wrapped) { if (raise_uninitialized_wrapper_error(self) == -1) return NULL; } return PyObject_Call(self->wrapped, args, kwds); } /* ------------------------------------------------------------------------- */; static PyGetSetDef WraptCallableObjectProxy_getset[] = { {"__module__", (getter)WraptObjectProxy_get_module, (setter)WraptObjectProxy_set_module, 0}, {"__doc__", (getter)WraptObjectProxy_get_doc, (setter)WraptObjectProxy_set_doc, 0}, {NULL}, }; PyTypeObject WraptCallableObjectProxy_Type = { PyVarObject_HEAD_INIT(NULL, 0) "CallableObjectProxy", /*tp_name*/ sizeof(WraptObjectProxyObject), /*tp_basicsize*/ 0, /*tp_itemsize*/ /* methods */ 0, /*tp_dealloc*/ 0, /*tp_print*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ 0, /*tp_compare*/ 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ (ternaryfunc)WraptCallableObjectProxy_call, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ 0, /*tp_doc*/ 0, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ offsetof(WraptObjectProxyObject, weakreflist), /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ 0, /*tp_methods*/ 0, /*tp_members*/ WraptCallableObjectProxy_getset, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ (initproc)WraptObjectProxy_init, /*tp_init*/ 0, /*tp_alloc*/ 0, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ }; /* ------------------------------------------------------------------------- */ static PyObject *WraptPartialCallableObjectProxy_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { WraptPartialCallableObjectProxyObject *self; self = (WraptPartialCallableObjectProxyObject *)WraptObjectProxy_new( type, args, kwds); if (!self) return NULL; self->args = NULL; self->kwargs = NULL; return (PyObject *)self; } /* ------------------------------------------------------------------------- */ static int WraptPartialCallableObjectProxy_raw_init( WraptPartialCallableObjectProxyObject *self, PyObject *wrapped, PyObject *args, PyObject *kwargs) { int result = 0; result = WraptObjectProxy_raw_init((WraptObjectProxyObject *)self, wrapped); if (result == 0) { Py_INCREF(args); Py_XDECREF(self->args); self->args = args; Py_XINCREF(kwargs); Py_XDECREF(self->kwargs); self->kwargs = kwargs; } return result; } /* ------------------------------------------------------------------------- */ static int WraptPartialCallableObjectProxy_init( WraptPartialCallableObjectProxyObject *self, PyObject *args, PyObject *kwds) { PyObject *wrapped = NULL; PyObject *fnargs = NULL; int result = 0; if (!PyObject_Length(args)) { PyErr_SetString(PyExc_TypeError, "__init__ of partial needs an argument"); return -1; } if (PyObject_Length(args) < 1) { PyErr_SetString(PyExc_TypeError, "partial type takes at least one argument"); return -1; } wrapped = PyTuple_GetItem(args, 0); if (!PyCallable_Check(wrapped)) { PyErr_SetString(PyExc_TypeError, "the first argument must be callable"); return -1; } fnargs = PyTuple_GetSlice(args, 1, PyTuple_Size(args)); if (!fnargs) return -1; result = WraptPartialCallableObjectProxy_raw_init(self, wrapped, fnargs, kwds); Py_DECREF(fnargs); return result; } /* ------------------------------------------------------------------------- */ static int WraptPartialCallableObjectProxy_traverse( WraptPartialCallableObjectProxyObject *self, visitproc visit, void *arg) { WraptObjectProxy_traverse((WraptObjectProxyObject *)self, visit, arg); Py_VISIT(self->args); Py_VISIT(self->kwargs); return 0; } /* ------------------------------------------------------------------------- */ static int WraptPartialCallableObjectProxy_clear( WraptPartialCallableObjectProxyObject *self) { WraptObjectProxy_clear((WraptObjectProxyObject *)self); Py_CLEAR(self->args); Py_CLEAR(self->kwargs); return 0; } /* ------------------------------------------------------------------------- */ static void WraptPartialCallableObjectProxy_dealloc( WraptPartialCallableObjectProxyObject *self) { PyObject_GC_UnTrack(self); WraptPartialCallableObjectProxy_clear(self); WraptObjectProxy_dealloc((WraptObjectProxyObject *)self); } /* ------------------------------------------------------------------------- */ static PyObject *WraptPartialCallableObjectProxy_call( WraptPartialCallableObjectProxyObject *self, PyObject *args, PyObject *kwds) { PyObject *fnargs = NULL; PyObject *fnkwargs = NULL; PyObject *result = NULL; long i; long offset; if (!self->object_proxy.wrapped) { if (raise_uninitialized_wrapper_error(&self->object_proxy) == -1) return NULL; } fnargs = PyTuple_New(PyTuple_Size(self->args) + PyTuple_Size(args)); for (i = 0; i < PyTuple_Size(self->args); i++) { PyObject *item; item = PyTuple_GetItem(self->args, i); Py_INCREF(item); PyTuple_SetItem(fnargs, i, item); } offset = PyTuple_Size(self->args); for (i = 0; i < PyTuple_Size(args); i++) { PyObject *item; item = PyTuple_GetItem(args, i); Py_INCREF(item); PyTuple_SetItem(fnargs, offset + i, item); } fnkwargs = PyDict_New(); if (self->kwargs && PyDict_Update(fnkwargs, self->kwargs) == -1) { Py_DECREF(fnargs); Py_DECREF(fnkwargs); return NULL; } if (kwds && PyDict_Update(fnkwargs, kwds) == -1) { Py_DECREF(fnargs); Py_DECREF(fnkwargs); return NULL; } result = PyObject_Call(self->object_proxy.wrapped, fnargs, fnkwargs); Py_DECREF(fnargs); Py_DECREF(fnkwargs); return result; } /* ------------------------------------------------------------------------- */; static PyGetSetDef WraptPartialCallableObjectProxy_getset[] = { {"__module__", (getter)WraptObjectProxy_get_module, (setter)WraptObjectProxy_set_module, 0}, {"__doc__", (getter)WraptObjectProxy_get_doc, (setter)WraptObjectProxy_set_doc, 0}, {NULL}, }; PyTypeObject WraptPartialCallableObjectProxy_Type = { PyVarObject_HEAD_INIT(NULL, 0) "PartialCallableObjectProxy", /*tp_name*/ sizeof(WraptPartialCallableObjectProxyObject), /*tp_basicsize*/ 0, /*tp_itemsize*/ /* methods */ (destructor)WraptPartialCallableObjectProxy_dealloc, /*tp_dealloc*/ 0, /*tp_print*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ 0, /*tp_compare*/ 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ (ternaryfunc)WraptPartialCallableObjectProxy_call, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ (traverseproc)WraptPartialCallableObjectProxy_traverse, /*tp_traverse*/ (inquiry)WraptPartialCallableObjectProxy_clear, /*tp_clear*/ 0, /*tp_richcompare*/ offsetof(WraptObjectProxyObject, weakreflist), /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ 0, /*tp_methods*/ 0, /*tp_members*/ WraptPartialCallableObjectProxy_getset, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ (initproc)WraptPartialCallableObjectProxy_init, /*tp_init*/ 0, /*tp_alloc*/ WraptPartialCallableObjectProxy_new, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ }; /* ------------------------------------------------------------------------- */ static PyObject *WraptFunctionWrapperBase_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { WraptFunctionWrapperObject *self; self = (WraptFunctionWrapperObject *)WraptObjectProxy_new(type, args, kwds); if (!self) return NULL; self->instance = NULL; self->wrapper = NULL; self->enabled = NULL; self->binding = NULL; self->parent = NULL; self->owner = NULL; return (PyObject *)self; } /* ------------------------------------------------------------------------- */ static int WraptFunctionWrapperBase_raw_init( WraptFunctionWrapperObject *self, PyObject *wrapped, PyObject *instance, PyObject *wrapper, PyObject *enabled, PyObject *binding, PyObject *parent, PyObject *owner) { int result = 0; result = WraptObjectProxy_raw_init((WraptObjectProxyObject *)self, wrapped); if (result == 0) { Py_INCREF(instance); Py_XDECREF(self->instance); self->instance = instance; Py_INCREF(wrapper); Py_XDECREF(self->wrapper); self->wrapper = wrapper; Py_INCREF(enabled); Py_XDECREF(self->enabled); self->enabled = enabled; Py_INCREF(binding); Py_XDECREF(self->binding); self->binding = binding; Py_INCREF(parent); Py_XDECREF(self->parent); self->parent = parent; Py_INCREF(owner); Py_XDECREF(self->owner); self->owner = owner; } return result; } /* ------------------------------------------------------------------------- */ static int WraptFunctionWrapperBase_init(WraptFunctionWrapperObject *self, PyObject *args, PyObject *kwds) { PyObject *wrapped = NULL; PyObject *instance = NULL; PyObject *wrapper = NULL; PyObject *enabled = Py_None; PyObject *binding = NULL; PyObject *parent = Py_None; PyObject *owner = Py_None; static PyObject *callable_str = NULL; char *const kwlist[] = {"wrapped", "instance", "wrapper", "enabled", "binding", "parent", "owner", NULL}; if (!callable_str) { callable_str = PyUnicode_InternFromString("callable"); } if (!PyArg_ParseTupleAndKeywords(args, kwds, "OOO|OOOO:FunctionWrapperBase", kwlist, &wrapped, &instance, &wrapper, &enabled, &binding, &parent, &owner)) { return -1; } if (!binding) binding = callable_str; return WraptFunctionWrapperBase_raw_init(self, wrapped, instance, wrapper, enabled, binding, parent, owner); } /* ------------------------------------------------------------------------- */ static int WraptFunctionWrapperBase_traverse(WraptFunctionWrapperObject *self, visitproc visit, void *arg) { WraptObjectProxy_traverse((WraptObjectProxyObject *)self, visit, arg); Py_VISIT(self->instance); Py_VISIT(self->wrapper); Py_VISIT(self->enabled); Py_VISIT(self->binding); Py_VISIT(self->parent); Py_VISIT(self->owner); return 0; } /* ------------------------------------------------------------------------- */ static int WraptFunctionWrapperBase_clear(WraptFunctionWrapperObject *self) { WraptObjectProxy_clear((WraptObjectProxyObject *)self); Py_CLEAR(self->instance); Py_CLEAR(self->wrapper); Py_CLEAR(self->enabled); Py_CLEAR(self->binding); Py_CLEAR(self->parent); Py_CLEAR(self->owner); return 0; } /* ------------------------------------------------------------------------- */ static void WraptFunctionWrapperBase_dealloc(WraptFunctionWrapperObject *self) { PyObject_GC_UnTrack(self); WraptFunctionWrapperBase_clear(self); WraptObjectProxy_dealloc((WraptObjectProxyObject *)self); } /* ------------------------------------------------------------------------- */ static PyObject *WraptFunctionWrapperBase_call(WraptFunctionWrapperObject *self, PyObject *args, PyObject *kwds) { PyObject *param_kwds = NULL; PyObject *result = NULL; static PyObject *function_str = NULL; static PyObject *callable_str = NULL; static PyObject *classmethod_str = NULL; static PyObject *instancemethod_str = NULL; if (!function_str) { function_str = PyUnicode_InternFromString("function"); callable_str = PyUnicode_InternFromString("callable"); classmethod_str = PyUnicode_InternFromString("classmethod"); instancemethod_str = PyUnicode_InternFromString("instancemethod"); } if (self->enabled != Py_None) { if (PyCallable_Check(self->enabled)) { PyObject *object = NULL; object = PyObject_CallFunctionObjArgs(self->enabled, NULL); if (!object) return NULL; if (PyObject_Not(object)) { Py_DECREF(object); return PyObject_Call(self->object_proxy.wrapped, args, kwds); } Py_DECREF(object); } else if (PyObject_Not(self->enabled)) { return PyObject_Call(self->object_proxy.wrapped, args, kwds); } } if (!kwds) { param_kwds = PyDict_New(); kwds = param_kwds; } if ((self->instance == Py_None) && (self->binding == function_str || PyObject_RichCompareBool(self->binding, function_str, Py_EQ) == 1 || self->binding == instancemethod_str || PyObject_RichCompareBool(self->binding, instancemethod_str, Py_EQ) == 1 || self->binding == callable_str || PyObject_RichCompareBool(self->binding, callable_str, Py_EQ) == 1 || self->binding == classmethod_str || PyObject_RichCompareBool(self->binding, classmethod_str, Py_EQ) == 1)) { PyObject *instance = NULL; instance = PyObject_GetAttrString(self->object_proxy.wrapped, "__self__"); if (instance) { result = PyObject_CallFunctionObjArgs(self->wrapper, self->object_proxy.wrapped, instance, args, kwds, NULL); Py_XDECREF(param_kwds); Py_DECREF(instance); return result; } else PyErr_Clear(); } result = PyObject_CallFunctionObjArgs(self->wrapper, self->object_proxy.wrapped, self->instance, args, kwds, NULL); Py_XDECREF(param_kwds); return result; } /* ------------------------------------------------------------------------- */ static PyObject * WraptFunctionWrapperBase_descr_get(WraptFunctionWrapperObject *self, PyObject *obj, PyObject *type) { PyObject *bound_type = NULL; PyObject *descriptor = NULL; PyObject *result = NULL; static PyObject *bound_type_str = NULL; static PyObject *function_str = NULL; static PyObject *callable_str = NULL; static PyObject *builtin_str = NULL; static PyObject *class_str = NULL; static PyObject *instancemethod_str = NULL; if (!bound_type_str) { bound_type_str = PyUnicode_InternFromString("__bound_function_wrapper__"); } if (!function_str) { function_str = PyUnicode_InternFromString("function"); callable_str = PyUnicode_InternFromString("callable"); builtin_str = PyUnicode_InternFromString("builtin"); class_str = PyUnicode_InternFromString("class"); instancemethod_str = PyUnicode_InternFromString("instancemethod"); } if (self->parent == Py_None) { if (self->binding == builtin_str || PyObject_RichCompareBool(self->binding, builtin_str, Py_EQ) == 1) { Py_INCREF(self); return (PyObject *)self; } if (self->binding == class_str || PyObject_RichCompareBool(self->binding, class_str, Py_EQ) == 1) { Py_INCREF(self); return (PyObject *)self; } if (Py_TYPE(self->object_proxy.wrapped)->tp_descr_get == NULL) { Py_INCREF(self); return (PyObject *)self; } descriptor = (Py_TYPE(self->object_proxy.wrapped)->tp_descr_get)( self->object_proxy.wrapped, obj, type); if (!descriptor) return NULL; if (Py_TYPE(self) != &WraptFunctionWrapper_Type) { bound_type = PyObject_GenericGetAttr((PyObject *)self, bound_type_str); if (!bound_type) PyErr_Clear(); } if (obj == NULL) obj = Py_None; result = PyObject_CallFunctionObjArgs( bound_type ? bound_type : (PyObject *)&WraptBoundFunctionWrapper_Type, descriptor, obj, self->wrapper, self->enabled, self->binding, self, type, NULL); Py_XDECREF(bound_type); Py_DECREF(descriptor); return result; } if (self->instance == Py_None && (self->binding == function_str || PyObject_RichCompareBool(self->binding, function_str, Py_EQ) == 1 || self->binding == instancemethod_str || PyObject_RichCompareBool(self->binding, instancemethod_str, Py_EQ) == 1 || self->binding == callable_str || PyObject_RichCompareBool(self->binding, callable_str, Py_EQ) == 1)) { PyObject *wrapped = NULL; static PyObject *wrapped_str = NULL; if (!wrapped_str) { wrapped_str = PyUnicode_InternFromString("__wrapped__"); } wrapped = PyObject_GetAttr(self->parent, wrapped_str); if (!wrapped) return NULL; if (Py_TYPE(wrapped)->tp_descr_get == NULL) { PyErr_Format(PyExc_AttributeError, "'%s' object has no attribute '__get__'", Py_TYPE(wrapped)->tp_name); Py_DECREF(wrapped); return NULL; } descriptor = (Py_TYPE(wrapped)->tp_descr_get)(wrapped, obj, type); Py_DECREF(wrapped); if (!descriptor) return NULL; if (Py_TYPE(self->parent) != &WraptFunctionWrapper_Type) { bound_type = PyObject_GenericGetAttr((PyObject *)self->parent, bound_type_str); if (!bound_type) PyErr_Clear(); } if (obj == NULL) obj = Py_None; result = PyObject_CallFunctionObjArgs( bound_type ? bound_type : (PyObject *)&WraptBoundFunctionWrapper_Type, descriptor, obj, self->wrapper, self->enabled, self->binding, self->parent, type, NULL); Py_XDECREF(bound_type); Py_DECREF(descriptor); return result; } Py_INCREF(self); return (PyObject *)self; } /* ------------------------------------------------------------------------- */ static PyObject * WraptFunctionWrapperBase_set_name(WraptFunctionWrapperObject *self, PyObject *args, PyObject *kwds) { PyObject *method = NULL; PyObject *result = NULL; if (!self->object_proxy.wrapped) { if (raise_uninitialized_wrapper_error(&self->object_proxy) == -1) return NULL; } method = PyObject_GetAttrString(self->object_proxy.wrapped, "__set_name__"); if (!method) { PyErr_Clear(); Py_INCREF(Py_None); return Py_None; } result = PyObject_Call(method, args, kwds); Py_DECREF(method); return result; } /* ------------------------------------------------------------------------- */ static PyObject * WraptFunctionWrapperBase_instancecheck(WraptFunctionWrapperObject *self, PyObject *instance) { PyObject *result = NULL; int check = 0; if (!self->object_proxy.wrapped) { if (raise_uninitialized_wrapper_error(&self->object_proxy) == -1) return NULL; } check = PyObject_IsInstance(instance, self->object_proxy.wrapped); if (check < 0) { return NULL; } result = check ? Py_True : Py_False; Py_INCREF(result); return result; } /* ------------------------------------------------------------------------- */ static PyObject * WraptFunctionWrapperBase_subclasscheck(WraptFunctionWrapperObject *self, PyObject *args) { PyObject *subclass = NULL; PyObject *object = NULL; PyObject *result = NULL; int check = 0; if (!self->object_proxy.wrapped) { if (raise_uninitialized_wrapper_error(&self->object_proxy) == -1) return NULL; } if (!PyArg_ParseTuple(args, "O", &subclass)) return NULL; object = PyObject_GetAttrString(subclass, "__wrapped__"); if (!object) PyErr_Clear(); check = PyObject_IsSubclass(object ? object : subclass, self->object_proxy.wrapped); Py_XDECREF(object); if (check == -1) return NULL; result = check ? Py_True : Py_False; Py_INCREF(result); return result; } /* ------------------------------------------------------------------------- */ static PyObject * WraptFunctionWrapperBase_get_self_instance(WraptFunctionWrapperObject *self, void *closure) { if (!self->instance) { Py_INCREF(Py_None); return Py_None; } Py_INCREF(self->instance); return self->instance; } /* ------------------------------------------------------------------------- */ static PyObject * WraptFunctionWrapperBase_get_self_wrapper(WraptFunctionWrapperObject *self, void *closure) { if (!self->wrapper) { Py_INCREF(Py_None); return Py_None; } Py_INCREF(self->wrapper); return self->wrapper; } /* ------------------------------------------------------------------------- */ static PyObject * WraptFunctionWrapperBase_get_self_enabled(WraptFunctionWrapperObject *self, void *closure) { if (!self->enabled) { Py_INCREF(Py_None); return Py_None; } Py_INCREF(self->enabled); return self->enabled; } /* ------------------------------------------------------------------------- */ static PyObject * WraptFunctionWrapperBase_get_self_binding(WraptFunctionWrapperObject *self, void *closure) { if (!self->binding) { Py_INCREF(Py_None); return Py_None; } Py_INCREF(self->binding); return self->binding; } /* ------------------------------------------------------------------------- */ static PyObject * WraptFunctionWrapperBase_get_self_parent(WraptFunctionWrapperObject *self, void *closure) { if (!self->parent) { Py_INCREF(Py_None); return Py_None; } Py_INCREF(self->parent); return self->parent; } /* ------------------------------------------------------------------------- */ static PyObject * WraptFunctionWrapperBase_get_self_owner(WraptFunctionWrapperObject *self, void *closure) { if (!self->owner) { Py_INCREF(Py_None); return Py_None; } Py_INCREF(self->owner); return self->owner; } /* ------------------------------------------------------------------------- */; static PyMethodDef WraptFunctionWrapperBase_methods[] = { {"__set_name__", (PyCFunction)WraptFunctionWrapperBase_set_name, METH_VARARGS | METH_KEYWORDS, 0}, {"__instancecheck__", (PyCFunction)WraptFunctionWrapperBase_instancecheck, METH_O, 0}, {"__subclasscheck__", (PyCFunction)WraptFunctionWrapperBase_subclasscheck, METH_VARARGS, 0}, {NULL, NULL}, }; /* ------------------------------------------------------------------------- */; static PyGetSetDef WraptFunctionWrapperBase_getset[] = { {"__module__", (getter)WraptObjectProxy_get_module, (setter)WraptObjectProxy_set_module, 0}, {"__doc__", (getter)WraptObjectProxy_get_doc, (setter)WraptObjectProxy_set_doc, 0}, {"_self_instance", (getter)WraptFunctionWrapperBase_get_self_instance, NULL, 0}, {"_self_wrapper", (getter)WraptFunctionWrapperBase_get_self_wrapper, NULL, 0}, {"_self_enabled", (getter)WraptFunctionWrapperBase_get_self_enabled, NULL, 0}, {"_self_binding", (getter)WraptFunctionWrapperBase_get_self_binding, NULL, 0}, {"_self_parent", (getter)WraptFunctionWrapperBase_get_self_parent, NULL, 0}, {"_self_owner", (getter)WraptFunctionWrapperBase_get_self_owner, NULL, 0}, {NULL}, }; PyTypeObject WraptFunctionWrapperBase_Type = { PyVarObject_HEAD_INIT(NULL, 0) "_FunctionWrapperBase", /*tp_name*/ sizeof(WraptFunctionWrapperObject), /*tp_basicsize*/ 0, /*tp_itemsize*/ /* methods */ (destructor)WraptFunctionWrapperBase_dealloc, /*tp_dealloc*/ 0, /*tp_print*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ 0, /*tp_compare*/ 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ (ternaryfunc)WraptFunctionWrapperBase_call, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ (traverseproc)WraptFunctionWrapperBase_traverse, /*tp_traverse*/ (inquiry)WraptFunctionWrapperBase_clear, /*tp_clear*/ 0, /*tp_richcompare*/ offsetof(WraptObjectProxyObject, weakreflist), /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ WraptFunctionWrapperBase_methods, /*tp_methods*/ 0, /*tp_members*/ WraptFunctionWrapperBase_getset, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ (descrgetfunc)WraptFunctionWrapperBase_descr_get, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ (initproc)WraptFunctionWrapperBase_init, /*tp_init*/ 0, /*tp_alloc*/ WraptFunctionWrapperBase_new, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ }; /* ------------------------------------------------------------------------- */ static PyObject * WraptBoundFunctionWrapper_call(WraptFunctionWrapperObject *self, PyObject *args, PyObject *kwds) { PyObject *param_args = NULL; PyObject *param_kwds = NULL; PyObject *wrapped = NULL; PyObject *instance = NULL; PyObject *result = NULL; static PyObject *function_str = NULL; static PyObject *callable_str = NULL; if (self->enabled != Py_None) { if (PyCallable_Check(self->enabled)) { PyObject *object = NULL; object = PyObject_CallFunctionObjArgs(self->enabled, NULL); if (!object) return NULL; if (PyObject_Not(object)) { Py_DECREF(object); return PyObject_Call(self->object_proxy.wrapped, args, kwds); } Py_DECREF(object); } else if (PyObject_Not(self->enabled)) { return PyObject_Call(self->object_proxy.wrapped, args, kwds); } } if (!function_str) { function_str = PyUnicode_InternFromString("function"); callable_str = PyUnicode_InternFromString("callable"); } /* * We need to do things different depending on whether we are likely * wrapping an instance method vs a static method or class method. */ if (self->binding == function_str || PyObject_RichCompareBool(self->binding, function_str, Py_EQ) == 1 || self->binding == callable_str || PyObject_RichCompareBool(self->binding, callable_str, Py_EQ) == 1) { // if (self->instance == Py_None) { // /* // * This situation can occur where someone is calling the // * instancemethod via the class type and passing the // * instance as the first argument. We need to shift the args // * before making the call to the wrapper and effectively // * bind the instance to the wrapped function using a partial // * so the wrapper doesn't see anything as being different. // */ // if (PyTuple_Size(args) == 0) { // PyErr_SetString(PyExc_TypeError, // "missing 1 required positional argument"); // return NULL; // } // instance = PyTuple_GetItem(args, 0); // if (!instance) // return NULL; // wrapped = PyObject_CallFunctionObjArgs( // (PyObject *)&WraptPartialCallableObjectProxy_Type, // self->object_proxy.wrapped, instance, NULL); // if (!wrapped) // return NULL; // param_args = PyTuple_GetSlice(args, 1, PyTuple_Size(args)); // if (!param_args) { // Py_DECREF(wrapped); // return NULL; // } // args = param_args; // } if (self->instance == Py_None && PyTuple_Size(args) != 0) { /* * This situation can occur where someone is calling the * instancemethod via the class type and passing the * instance as the first argument. We need to shift the args * before making the call to the wrapper and effectively * bind the instance to the wrapped function using a partial * so the wrapper doesn't see anything as being different. */ instance = PyTuple_GetItem(args, 0); if (!instance) return NULL; if (PyObject_IsInstance(instance, self->owner) == 1) { wrapped = PyObject_CallFunctionObjArgs( (PyObject *)&WraptPartialCallableObjectProxy_Type, self->object_proxy.wrapped, instance, NULL); if (!wrapped) return NULL; param_args = PyTuple_GetSlice(args, 1, PyTuple_Size(args)); if (!param_args) { Py_DECREF(wrapped); return NULL; } args = param_args; } else { instance = self->instance; } } else { instance = self->instance; } if (!wrapped) { Py_INCREF(self->object_proxy.wrapped); wrapped = self->object_proxy.wrapped; } if (!kwds) { param_kwds = PyDict_New(); kwds = param_kwds; } result = PyObject_CallFunctionObjArgs(self->wrapper, wrapped, instance, args, kwds, NULL); Py_XDECREF(param_args); Py_XDECREF(param_kwds); Py_DECREF(wrapped); return result; } else { /* * As in this case we would be dealing with a classmethod or * staticmethod, then _self_instance will only tell us whether * when calling the classmethod or staticmethod they did it via * an instance of the class it is bound to and not the case * where done by the class type itself. We thus ignore * _self_instance and use the __self__ attribute of the bound * function instead. For a classmethod, this means instance will * be the class type and for a staticmethod it will be None. * This is probably the more useful thing we can pass through * even though we loose knowledge of whether they were called on * the instance vs the class type, as it reflects what they have * available in the decoratored function. */ instance = PyObject_GetAttrString(self->object_proxy.wrapped, "__self__"); if (!instance) { PyErr_Clear(); Py_INCREF(Py_None); instance = Py_None; } if (!kwds) { param_kwds = PyDict_New(); kwds = param_kwds; } result = PyObject_CallFunctionObjArgs( self->wrapper, self->object_proxy.wrapped, instance, args, kwds, NULL); Py_XDECREF(param_kwds); Py_DECREF(instance); return result; } } /* ------------------------------------------------------------------------- */ static PyGetSetDef WraptBoundFunctionWrapper_getset[] = { {"__module__", (getter)WraptObjectProxy_get_module, (setter)WraptObjectProxy_set_module, 0}, {"__doc__", (getter)WraptObjectProxy_get_doc, (setter)WraptObjectProxy_set_doc, 0}, {NULL}, }; PyTypeObject WraptBoundFunctionWrapper_Type = { PyVarObject_HEAD_INIT(NULL, 0) "BoundFunctionWrapper", /*tp_name*/ sizeof(WraptFunctionWrapperObject), /*tp_basicsize*/ 0, /*tp_itemsize*/ /* methods */ 0, /*tp_dealloc*/ 0, /*tp_print*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ 0, /*tp_compare*/ 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ (ternaryfunc)WraptBoundFunctionWrapper_call, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ 0, /*tp_doc*/ 0, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ offsetof(WraptObjectProxyObject, weakreflist), /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ 0, /*tp_methods*/ 0, /*tp_members*/ WraptBoundFunctionWrapper_getset, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ 0, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ }; /* ------------------------------------------------------------------------- */ static int WraptFunctionWrapper_init(WraptFunctionWrapperObject *self, PyObject *args, PyObject *kwds) { PyObject *wrapped = NULL; PyObject *wrapper = NULL; PyObject *enabled = Py_None; PyObject *binding = NULL; PyObject *instance = NULL; static PyObject *function_str = NULL; static PyObject *classmethod_str = NULL; static PyObject *staticmethod_str = NULL; static PyObject *callable_str = NULL; static PyObject *builtin_str = NULL; static PyObject *class_str = NULL; static PyObject *instancemethod_str = NULL; int result = 0; char *const kwlist[] = {"wrapped", "wrapper", "enabled", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO|O:FunctionWrapper", kwlist, &wrapped, &wrapper, &enabled)) { return -1; } if (!function_str) { function_str = PyUnicode_InternFromString("function"); } if (!classmethod_str) { classmethod_str = PyUnicode_InternFromString("classmethod"); } if (!staticmethod_str) { staticmethod_str = PyUnicode_InternFromString("staticmethod"); } if (!callable_str) { callable_str = PyUnicode_InternFromString("callable"); } if (!builtin_str) { builtin_str = PyUnicode_InternFromString("builtin"); } if (!class_str) { class_str = PyUnicode_InternFromString("class"); } if (!instancemethod_str) { instancemethod_str = PyUnicode_InternFromString("instancemethod"); } if (PyObject_IsInstance(wrapped, (PyObject *)&WraptFunctionWrapperBase_Type)) { binding = PyObject_GetAttrString(wrapped, "_self_binding"); } if (!binding) { if (PyCFunction_Check(wrapped)) { binding = builtin_str; } else if (PyObject_IsInstance(wrapped, (PyObject *)&PyFunction_Type)) { binding = function_str; } else if (PyObject_IsInstance(wrapped, (PyObject *)&PyClassMethod_Type)) { binding = classmethod_str; } else if (PyObject_IsInstance(wrapped, (PyObject *)&PyType_Type)) { binding = class_str; } else if (PyObject_IsInstance(wrapped, (PyObject *)&PyStaticMethod_Type)) { binding = staticmethod_str; } else if ((instance = PyObject_GetAttrString(wrapped, "__self__")) != 0) { if (PyObject_IsInstance(instance, (PyObject *)&PyType_Type)) { binding = classmethod_str; } else if (PyObject_IsInstance(wrapped, (PyObject *)&PyMethod_Type)) { binding = instancemethod_str; } else binding = callable_str; Py_DECREF(instance); } else { PyErr_Clear(); binding = callable_str; } } result = WraptFunctionWrapperBase_raw_init( self, wrapped, Py_None, wrapper, enabled, binding, Py_None, Py_None); return result; } /* ------------------------------------------------------------------------- */ static PyGetSetDef WraptFunctionWrapper_getset[] = { {"__module__", (getter)WraptObjectProxy_get_module, (setter)WraptObjectProxy_set_module, 0}, {"__doc__", (getter)WraptObjectProxy_get_doc, (setter)WraptObjectProxy_set_doc, 0}, {NULL}, }; PyTypeObject WraptFunctionWrapper_Type = { PyVarObject_HEAD_INIT(NULL, 0) "FunctionWrapper", /*tp_name*/ sizeof(WraptFunctionWrapperObject), /*tp_basicsize*/ 0, /*tp_itemsize*/ /* methods */ 0, /*tp_dealloc*/ 0, /*tp_print*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ 0, /*tp_compare*/ 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ 0, /*tp_doc*/ 0, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ offsetof(WraptObjectProxyObject, weakreflist), /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ 0, /*tp_methods*/ 0, /*tp_members*/ WraptFunctionWrapper_getset, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ (initproc)WraptFunctionWrapper_init, /*tp_init*/ 0, /*tp_alloc*/ 0, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ }; /* ------------------------------------------------------------------------- */ static struct PyModuleDef moduledef = { PyModuleDef_HEAD_INIT, "_wrappers", /* m_name */ NULL, /* m_doc */ -1, /* m_size */ NULL, /* m_methods */ NULL, /* m_reload */ NULL, /* m_traverse */ NULL, /* m_clear */ NULL, /* m_free */ }; static PyObject *moduleinit(void) { PyObject *module; module = PyModule_Create(&moduledef); if (module == NULL) return NULL; if (PyType_Ready(&WraptObjectProxy_Type) < 0) return NULL; /* Ensure that inheritance relationships specified. */ WraptCallableObjectProxy_Type.tp_base = &WraptObjectProxy_Type; WraptPartialCallableObjectProxy_Type.tp_base = &WraptObjectProxy_Type; WraptFunctionWrapperBase_Type.tp_base = &WraptObjectProxy_Type; WraptBoundFunctionWrapper_Type.tp_base = &WraptFunctionWrapperBase_Type; WraptFunctionWrapper_Type.tp_base = &WraptFunctionWrapperBase_Type; if (PyType_Ready(&WraptCallableObjectProxy_Type) < 0) return NULL; if (PyType_Ready(&WraptPartialCallableObjectProxy_Type) < 0) return NULL; if (PyType_Ready(&WraptFunctionWrapperBase_Type) < 0) return NULL; if (PyType_Ready(&WraptBoundFunctionWrapper_Type) < 0) return NULL; if (PyType_Ready(&WraptFunctionWrapper_Type) < 0) return NULL; Py_INCREF(&WraptObjectProxy_Type); PyModule_AddObject(module, "ObjectProxy", (PyObject *)&WraptObjectProxy_Type); Py_INCREF(&WraptCallableObjectProxy_Type); PyModule_AddObject(module, "CallableObjectProxy", (PyObject *)&WraptCallableObjectProxy_Type); Py_INCREF(&WraptPartialCallableObjectProxy_Type); PyModule_AddObject(module, "PartialCallableObjectProxy", (PyObject *)&WraptPartialCallableObjectProxy_Type); Py_INCREF(&WraptFunctionWrapper_Type); PyModule_AddObject(module, "FunctionWrapper", (PyObject *)&WraptFunctionWrapper_Type); Py_INCREF(&WraptFunctionWrapperBase_Type); PyModule_AddObject(module, "_FunctionWrapperBase", (PyObject *)&WraptFunctionWrapperBase_Type); Py_INCREF(&WraptBoundFunctionWrapper_Type); PyModule_AddObject(module, "BoundFunctionWrapper", (PyObject *)&WraptBoundFunctionWrapper_Type); #ifdef Py_GIL_DISABLED PyUnstable_Module_SetGIL(module, Py_MOD_GIL_NOT_USED); #endif return module; } PyMODINIT_FUNC PyInit__wrappers(void) { return moduleinit(); } /* ------------------------------------------------------------------------- */