Page 172
example.c
#define PY_SSIZE_T_CLEAN
#include <Python.h>
static PyTypeObject MyType1 = {
PyVarObject_HEAD_INIT(NULL, 0)
.tp_name = "example.myObject",
.tp_doc = PyDoc_STR("My Custom object"),
.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION
};
static struct PyModuleDef myModule = {
PyModuleDef_HEAD_INIT,
"example",
"C library to test API",
-1,
NULL};
PyMODINIT_FUNC PyInit_example(void)
{
PyObject *m = PyModule_Create(&myModule);
if (m == NULL)
return NULL;
int res = PyType_Ready(&MyType1);
PyModule_AddObject(m, "MyClass", (PyObject *)&MyType1);
return m;
}
import example
myclass=example.MyClass
print(myclass)
print(myclass.__dict__)
Page 173
#define PY_SSIZE_T_CLEAN
#include <Python.h>
static PyTypeObject MyType1 = {
PyVarObject_HEAD_INIT(NULL, 0)
.tp_name = "example.myObject",
.tp_doc = PyDoc_STR("My Custom object"),
.tp_flags = Py_TPFLAGS_DEFAULT,
.tp_basicsize = sizeof(PyObject),
.tp_itemsize = 0,
.tp_new = PyType_GenericNew,
};
static struct PyModuleDef myModule = {
PyModuleDef_HEAD_INIT,
"example",
"C library to test API",
-1,
NULL};
PyMODINIT_FUNC PyInit_example(void)
{
PyObject *m = PyModule_Create(&myModule);
if (m == NULL)
return NULL;
int res = PyType_Ready(&MyType1);
PyModule_AddObject(m, "MyClass", (PyObject *)&MyType1);
return m;
}
test.py
import example
myInst=example.MyClass()
print(myInst)
print(myInst.__dir__())
print(myInst.__sizeof__())
Page 176
exampe.c
#define PY_SSIZE_T_CLEAN
#include <Python.h>
static PyObject *myFunc(PyObject *self, PyObject *args)
{
printf("hello world\n");
Py_RETURN_NONE;
}
static PyMethodDef myFunc_def = {
"myFunc",
myFunc,
METH_VARARGS,
"the doc string"};
static PyTypeObject MyType1 = {
PyVarObject_HEAD_INIT(NULL, 0)
.tp_name = "example.myObject",
.tp_doc = PyDoc_STR("My Custom object"),
.tp_flags = Py_TPFLAGS_DEFAULT,
.tp_basicsize = sizeof(PyObject),
.tp_itemsize = 0,
.tp_new = PyType_GenericNew,
};
static struct PyModuleDef myModule = {
PyModuleDef_HEAD_INIT,
"example",
"C library to test API",
-1,
NULL};
PyMODINIT_FUNC PyInit_example(void)
{
PyObject *m = PyModule_Create(&myModule);
if (m == NULL)
return NULL;
PyObject *mydict = PyDict_New();
PyObject *val = PyLong_FromLong(42);
PyDict_SetItemString(mydict, "myValue", val);
Py_DECREF(val);
PyObject *myPyFun = PyCFunction_New(&myFunc_def, (PyObject *)&MyType1);
PyDict_SetItemString(mydict, "myFunc", myPyFun);
MyType1.tp_dict = mydict;
int res = PyType_Ready(&MyType1);
PyModule_AddObject(m, "MyClass", (PyObject *)&MyType1);
return m;
}
test.py
import example
example.MyClass.myFunc()
myInst=example.MyClass()
myInst.myFunc()
Page 177
example.c
#define PY_SSIZE_T_CLEAN
#include <Python.h>
#include <stddef.h>
typedef struct
{
PyObject_HEAD
PyObject *dict;
} MyObject;
static PyObject *myFunc(PyObject *self, PyObject *args)
{
printf("hello world\n");
Py_RETURN_NONE;
}
static PyMethodDef myFunc_def = {
"myFunc",
myFunc,
METH_VARARGS,
"the doc string"};
static PyTypeObject MyType1 = {
PyVarObject_HEAD_INIT(NULL, 0)
.tp_name = "example.myObject",
.tp_doc = PyDoc_STR("My Custom object"),
.tp_flags = Py_TPFLAGS_DEFAULT,
.tp_basicsize = sizeof(MyObject),
.tp_itemsize = 0,
.tp_dictoffset=offsetof(MyObject, dict),
.tp_new = PyType_GenericNew,
};
static struct PyModuleDef myModule = {
PyModuleDef_HEAD_INIT,
"example",
"C library to test API",
-1,
NULL};
PyMODINIT_FUNC PyInit_example(void)
{
PyObject *m = PyModule_Create(&myModule);
if (m == NULL)
return NULL;
PyObject *mydict = PyDict_New();
PyObject *val = PyLong_FromLong(42);
PyDict_SetItemString(mydict, "myValue", val);
Py_DECREF(val);
PyObject *myPyFun = PyCFunction_New(&myFunc_def, (PyObject *)&MyType1);
PyDict_SetItemString(mydict, "myFunc", myPyFun);
MyType1.tp_dict = mydict;
int res = PyType_Ready(&MyType1);
PyModule_AddObject(m, "MyClass", (PyObject *)&MyType1);
return m;
}
test.py
import example
example.MyClass.myFunc()
myInst=example.MyClass()
myInst.myFunc()
myInst.myValue=43
print(myInst.myValue)
myInst.myVal1=42
print(myInst.myVal1)
Page 180
example.c
#define PY_SSIZE_T_CLEAN
#include <Python.h>
#include <stddef.h>
typedef struct
{
PyObject_HEAD
PyObject *dict;
} MyObject;
static PyObject *myFunc(PyObject *self, PyObject *args)
{
printf("hello world\n");
Py_RETURN_NONE;
}
static PyMethodDef myFunc_def = {
"myFunc",
myFunc,
METH_VARARGS,
"the doc string"};
static PyObject *Custom_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
MyObject *self;
self = (MyObject *)type->tp_alloc(type, 0);
return (PyObject *)self;
}
static int Custom_init(MyObject *self, PyObject *args, PyObject *kwds)
{
PyObject *myPyFunc = PyCFunction_New(&myFunc_def, (PyObject *)self);
PyObject *myPyMethod = PyInstanceMethod_New(myPyFunc);
int res = PyObject_SetAttrString((PyObject *)self, "MyMethod", myPyMethod);
return 0;
}
static PyTypeObject MyType1 = {
PyVarObject_HEAD_INIT(NULL, 0)
.tp_name = "example.myObject",
.tp_doc = PyDoc_STR("My Custom object"),
.tp_flags = Py_TPFLAGS_DEFAULT,
.tp_basicsize = sizeof(MyObject),
.tp_itemsize = 0,
.tp_dictoffset = offsetof(MyObject, dict),
.tp_new = Custom_new,
.tp_init = (initproc)Custom_init,
};
static struct PyModuleDef myModule = {
PyModuleDef_HEAD_INIT,
"example",
"C library to test API",
-1,
NULL};
PyMODINIT_FUNC PyInit_example(void)
{
PyObject *m = PyModule_Create(&myModule);
if (m == NULL)
return NULL;
PyObject *mydict = PyDict_New();
PyObject *val = PyLong_FromLong(42);
PyDict_SetItemString(mydict, "myValue", val);
Py_DECREF(val);
PyObject *myPyFun = PyCFunction_New(&myFunc_def, (PyObject *)&MyType1);
PyDict_SetItemString(mydict, "myFunc", myPyFun);
MyType1.tp_dict = mydict;
int res = PyType_Ready(&MyType1);
PyModule_AddObject(m, "MyClass", (PyObject *)&MyType1);
return m;
}
test.py
import example
example.MyClass.myFunc()
myInst=example.MyClass()
myInst.myFunc()
myInst.myValue=43
print(myInst.myValue)
myInst.myVal1=42
print(myInst.myVal1)
myInst.MyMethod()
Page 185
example.c
#define PY_SSIZE_T_CLEAN
#include <Python.h>
#include <stddef.h>
#include "structmember.h"
typedef struct
{
PyObject_HEAD
int myVal;
} MyObject;
static PyObject *myFunc(MyObject *self, PyObject *args)
{
printf("%d\n", self->myVal);
printf("hello world\n");
Py_RETURN_NONE;
};
static PyMemberDef myMemberdef = {
"MyVar",
T_INT,
offsetof(MyObject, myVal),
0,
"MyInstanceAttr"};
static PyMethodDef myFunc_def = {
"myFunc",
(PyCFunction)myFunc,
METH_VARARGS,
"the doc string"};
static PyTypeObject MyType1 = {
.ob_base = PyVarObject_HEAD_INIT(NULL, 0)
.tp_name = "example.myObject",
.tp_doc = PyDoc_STR("My Custom object"),
.tp_flags = Py_TPFLAGS_DEFAULT,
.tp_basicsize = sizeof(MyObject),
.tp_itemsize = 0,
.tp_new =PyType_GenericNew,
};
static struct PyModuleDef myModule = {
PyModuleDef_HEAD_INIT,
"example",
"C library to test API",
-1,
NULL};
PyMODINIT_FUNC PyInit_example(void)
{
PyObject *m = PyModule_Create(&myModule);
if (m == NULL)
return NULL;
PyObject *mydict=PyDict_New();
PyObject *myMethodDesc = PyDescr_NewMethod(&MyType1, &myFunc_def);
int res = PyDict_SetItemString(mydict, "MyMethod", myMethodDesc);
PyObject *myMemberDesc = PyDescr_NewMember(&MyType1, &myMemberdef);
res = PyDict_SetItemString(mydict, "MyVar", myMemberDesc);
MyType1.tp_dict=mydict;
res = PyType_Ready(&MyType1);
PyModule_AddObject(m, "MyClass", (PyObject *)&MyType1);
return m;
}
test.py
import example
myInst=example.MyClass()
myInst.MyMethod()
myInst.MyVar=43
print(myInst.MyVar)
Page 187
example.c
#define PY_SSIZE_T_CLEAN
#include <Python.h>
#include <stddef.h>
#include "structmember.h"
typedef struct
{
PyObject_HEAD
int myVal;
} MyObject;
static PyObject *myFunc(MyObject *self, PyObject *args)
{
printf("%d\n", self->myVal);
printf("hello world\n");
Py_RETURN_NONE;
};
static PyMemberDef myMemberdef[] = {
{ "MyVar",T_INT,offsetof(MyObject, myVal),0,"MyInstanceAttr"},
{NULL}
};
static PyMethodDef myMethodDef[] = {
{"MyMethod",(PyCFunction)myFunc,METH_VARARGS,"the doc string"},
{NULL}
};
static PyTypeObject MyType1 = {
.ob_base = PyVarObject_HEAD_INIT(NULL, 0)
.tp_name = "example.myObject",
.tp_doc = PyDoc_STR("My Custom object"),
.tp_flags = Py_TPFLAGS_DEFAULT,
.tp_basicsize = sizeof(MyObject),
.tp_itemsize = 0,
.tp_new = PyType_GenericNew,
.tp_members = myMemberdef,
.tp_methods = myMethodDef,
};
static struct PyModuleDef myModule = {
PyModuleDef_HEAD_INIT,
"example",
"C library to test API",
-1,
NULL};
PyMODINIT_FUNC PyInit_example(void)
{
PyObject *m = PyModule_Create(&myModule);
if (m == NULL)
return NULL;
int res = PyType_Ready(&MyType1);
PyModule_AddObject(m, "MyClass", (PyObject *)&MyType1);
return m;
}
test.py
import example
myInst=example.MyClass()
myInst.MyMethod()
myInst.MyVar=43
print(myInst.MyVar)
Page 190
example.c
#define PY_SSIZE_T_CLEAN
#include <Python.h>
#include <stddef.h>
#include "structmember.h"
typedef struct
{
PyObject_HEAD
PyObject *myProp;
} MyObject;
static PyObject *getVal(MyObject *self, void *extra)
{
return Py_NewRef(self->myProp);
}
int setVal(MyObject *self, PyObject *val, void *extra)
{
Py_XSETREF(self->myProp, Py_XNewRef(val));
return 0;
}
static PyGetSetDef myGetSetDef[] = {
{"myProperty", (getter)getVal, (setter)setVal, "Example get set", NULL},
{NULL}};
static PyTypeObject MyType1 = {
.ob_base = PyVarObject_HEAD_INIT(NULL, 0)
.tp_name = "example.myObject",
.tp_doc = PyDoc_STR("My Custom object"),
.tp_flags = Py_TPFLAGS_DEFAULT,
.tp_basicsize = sizeof(MyObject),
.tp_itemsize = 0,
.tp_new = PyType_GenericNew,
.tp_getset = myGetSetDef,
};
static struct PyModuleDef myModule = {
PyModuleDef_HEAD_INIT,
"example",
"C library to test API",
-1,
NULL};
PyMODINIT_FUNC PyInit_example(void)
{
PyObject *m = PyModule_Create(&myModule);
if (m == NULL)
return NULL;
int res = PyType_Ready(&MyType1);
PyModule_AddObject(m, "MyClass", (PyObject *)&MyType1);
return m;
}
test.py
import example
myInst=example.MyClass()
myInst.myProperty=42
print(myInst.myProperty)
