all bmesh operators can now be accessed from bmesh.ops.* using a generic wrapper,
authorCampbell Barton <ideasman42@gmail.com>
Sat, 30 Jun 2012 11:14:10 +0000 (11:14 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Sat, 30 Jun 2012 11:14:10 +0000 (11:14 +0000)
argument parsing still needs to have support added for vector, matrix and element types.

source/blender/bmesh/intern/bmesh_operator_api.h
source/blender/bmesh/intern/bmesh_operators.c
source/blender/python/bmesh/bmesh_py_api.c
source/blender/python/bmesh/bmesh_py_ops.c

index c7dfb64e9ec633bd05f2143293f9ff591b1b997d..c6dd33b7a4b90b9cca9c4ec406991c3bbff59015 100644 (file)
@@ -352,6 +352,9 @@ int BMO_vert_edge_flags_count(BMesh *bm, BMVert *v, const short oflag);
 void BMO_slot_map_to_flag(BMesh *bm, BMOperator *op, const char *slot_name,
                           const char hflag, const short oflag);
 
+void BMO_slot_buffer_from_all(BMesh *bm, BMOperator *op, const char *slot_name,
+                              const char htype);
+
 /* this part of the API is used to iterate over element buffer or
  * mapping slots.
  *
index e9627cc7a29b7daea516075e553ccf11fb1647f1..48d3cc3721ab00244ca18a618486891e91fbfd94 100644 (file)
@@ -225,9 +225,9 @@ int BMO_slot_exists(BMOperator *op, const char *slot_name)
  *
  * Returns a pointer to the slot of type 'slot_code'
  */
-BMOpSlot *BMO_slot_get(BMOperator *op, const char *slot_namee)
+BMOpSlot *BMO_slot_get(BMOperator *op, const char *slot_name)
 {
-       int slot_code = bmo_name_to_slotcode_check(opdefines[op->type], slot_namee);
+       int slot_code = bmo_name_to_slotcode_check(opdefines[op->type], slot_name);
 
        if (slot_code < 0) {
                return &BMOpEmptySlot;
@@ -645,7 +645,7 @@ static void *bmo_slot_buffer_alloc(BMOperator *op, const char *slot_name, int le
  *
  * Copies all elements of a certain type into an operator slot.
  */
-static void BMO_slot_buffer_from_all(BMesh *bm, BMOperator *op, const char *slot_name, const char htype)
+void BMO_slot_buffer_from_all(BMesh *bm, BMOperator *op, const char *slot_name, const char htype)
 {
        BMOpSlot *output = BMO_slot_get(op, slot_name);
        int totelement = 0, i = 0;
index 2cfe5847e5535fca92380f41d7e542d6c55f9dc6..b2fd1d3d61c2cc4a27770ca110cb17bc6f56a80c 100644 (file)
@@ -145,7 +145,8 @@ PyObject *BPyInit_bmesh(void)
        Py_INCREF(submodule);
 
        PyModule_AddObject(mod, "ops", (submodule = BPyInit_bmesh_ops()));
-       PyDict_SetItemString(sys_modules, PyModule_GetName(submodule), submodule);
+       /* PyDict_SetItemString(sys_modules, PyModule_GetName(submodule), submodule); */
+       PyDict_SetItemString(sys_modules, "bmesh.ops", submodule); /* fake module */
        Py_INCREF(submodule);
 
        PyModule_AddObject(mod, "utils", (submodule = BPyInit_bmesh_utils()));
index b9958621389df4c53986dea92ec5f0621953d8f7..d64c1206d99ee8ede05df11fb27e421ccf5addbc 100644 (file)
@@ -60,115 +60,190 @@ static int bpy_bm_op_as_py_error(BMesh *bm)
        return 0;
 }
 
-PyDoc_STRVAR(bpy_bm_ops_convex_hull_doc,
-".. method:: convex_hull(bmesh, filter)\n"
-"\n"
-"   Face split with optional intermediate points.\n"
-"\n"
-"   :arg bmesh: The face to cut.\n"
-"   :type bmesh: :class:`bmesh.types.BMFace`\n"
-"   :arg filter: Set containing vertex flags to apply the operator.\n"
-"   :type filter: set\n"
-);
-static PyObject *bpy_bm_ops_convex_hull(PyObject *UNUSED(self), PyObject *args, PyObject *kw)
-{
-       static const char *kwlist[] = {"bmesh", "filter", NULL};
-
-       BPy_BMesh *py_bm;
-       BMesh *bm;
-
-       PyObject *filter;
-       int filter_flags;
-       BMOperator bmop;
-
-       if (!PyArg_ParseTupleAndKeywords(args, kw, "O!O!:convex_hull", (char **)kwlist,
-                                        &BPy_BMesh_Type, &py_bm,
-                                        &PySet_Type,  &filter))
-       {
-               return NULL;
-       }
+/* bmesh operator 'bmesh.ops.*' callable types
+ * ******************************************* */
+PyTypeObject bmesh_op_Type;
 
-       BPY_BM_CHECK_OBJ(py_bm);
-       bm = py_bm->bm;
-
-       if (filter != NULL && PyC_FlagSet_ToBitfield(bpy_bm_hflag_all_flags, filter,
-                                                    &filter_flags, "convex_hull") == -1)
-       {
-               return NULL;
-       }
+typedef struct {
+       PyObject_HEAD /* required python macro   */
+       const char *opname;
+} BPy_BMeshOpFunc;
 
-       BMO_op_initf(bm, &bmop,
-                    "convex_hull input=%hv",
-                    filter_flags);
-       BMO_op_exec(bm, &bmop);
-       BMO_op_finish(bm, &bmop);
+PyObject *bpy_bmesh_op_CreatePyObject(const char *opname)
+{
+       BPy_BMeshOpFunc *self = PyObject_New(BPy_BMeshOpFunc, &bmesh_op_Type);
 
-       if (bpy_bm_op_as_py_error(bm) == -1) {
-               return NULL;
-       }
+       self->opname = opname;
 
-       /* TODO, return values */
-       Py_RETURN_NONE;
+       return (PyObject *)self;
 }
 
+static PyObject *bpy_bmesh_op_repr(BPy_BMeshOpFunc *self)
+{
+       return PyUnicode_FromFormat("<%.200s bmesh.ops.%.200s()>",
+                                   Py_TYPE(self)->tp_name,
+                                   self->opname);
+}
 
 
-
-PyDoc_STRVAR(bpy_bm_ops_dissolve_limit_doc,
-".. method:: dissolve_limit(bmesh, filter, dist)\n"
-"\n"
-"   Face split with optional intermediate points.\n"
-"\n"
-"   :arg bmesh: The face to cut.\n"
-"   :type bmesh: :class:`bmesh.types.BMFace`\n"
-"   :arg filter: Set containing vertex flags to apply the operator.\n"
-"   :type filter: set\n"
-"   :arg dist: Distance limit.\n"
-"   :type dist: float\n"
-);
-static PyObject *bpy_bm_ops_dissolve_limit(PyObject *UNUSED(self), PyObject *args, PyObject *kw)
+static PyObject *pyrna_op_call(BPy_BMeshOpFunc *self, PyObject *args, PyObject *kw)
 {
-       static const char *kwlist[] = {"bmesh", "filter_verts", "filter_edges", "angle_limit", NULL};
-
        BPy_BMesh *py_bm;
        BMesh *bm;
 
-       PyObject *filter_verts;
-       int filter_verts_flags;
-       PyObject *filter_edges;
-       int filter_edges_flags;
-
-       float angle_limit = 0.0f;
-
        BMOperator bmop;
 
-       if (!PyArg_ParseTupleAndKeywords(args, kw, "O!O!O!|f:dissolve_limit", (char **)kwlist,
-                                        &BPy_BMesh_Type, &py_bm,
-                                        &PySet_Type, &filter_verts,
-                                        &PySet_Type, &filter_edges,
-                                        &angle_limit))
+       if ((PyTuple_GET_SIZE(args) == 1) &&
+           (py_bm = (BPy_BMesh *)PyTuple_GET_ITEM(args, 0)) &&
+           (BPy_BMesh_Check(py_bm))
+               )
        {
+               BPY_BM_CHECK_OBJ(py_bm);
+               bm = py_bm->bm;
+       }
+       else {
+               PyErr_SetString(PyExc_TypeError,
+                               "calling a bmesh operator expects a single BMesh (non keyword) "
+                               "as the first argument");
                return NULL;
        }
 
-       BPY_BM_CHECK_OBJ(py_bm);
-       bm = py_bm->bm;
-
-       if (filter_verts != NULL && PyC_FlagSet_ToBitfield(bpy_bm_hflag_all_flags, filter_verts,
-                                                          &filter_verts_flags, "dissolve_limit") == -1)
-       {
-               return NULL;
+       /* TODO - error check this!, though we do the error check on attribute access */
+       BMO_op_init(bm, &bmop, self->opname);
+
+       if (kw && PyDict_Size(kw) > 0) {
+               /* setup properties, see bpy_rna.c: pyrna_py_to_prop()
+                * which shares this logic for parsing properties */
+
+               PyObject *key, *value;
+               Py_ssize_t pos = 0;
+               while (PyDict_Next(kw, &pos, &key, &value)) {
+                       const char *slot_name = _PyUnicode_AsString(key);
+                       BMOpSlot *slot = BMO_slot_get(&bmop, slot_name);
+
+                       if (slot == NULL) {
+                               PyErr_Format(PyExc_TypeError,
+                                            "%.200s: keyword \"%.200s\" is invalid for this operator",
+                                            self->opname, slot_name);
+                               return NULL;
+                       }
+
+                       /* now assign the value */
+                       switch (slot->slot_type) {
+                               case BMO_OP_SLOT_BOOL:
+                               {
+                                       int param;
+
+                                       param = PyLong_AsLong(value);
+
+                                       if (param < 0) {
+                                               PyErr_Format(PyExc_TypeError,
+                                                            "%.200s: keyword \"%.200s\" expected True/False or 0/1, not %.200s",
+                                                            self->opname, slot_name, Py_TYPE(value)->tp_name);
+                                               return NULL;
+                                       }
+                                       else {
+                                               slot->data.i = param;
+                                       }
+
+                                       break;
+                               }
+                               case BMO_OP_SLOT_INT:
+                               {
+                                       int overflow;
+                                       long param = PyLong_AsLongAndOverflow(value, &overflow);
+                                       if (overflow || (param > INT_MAX) || (param < INT_MIN)) {
+                                               PyErr_Format(PyExc_ValueError,
+                                                            "%.200s: keyword \"%.200s\" value not in 'int' range "
+                                                            "(" STRINGIFY(INT_MIN) ", " STRINGIFY(INT_MAX) ")",
+                                                            self->opname, slot_name, Py_TYPE(value)->tp_name);
+                                               return NULL;
+                                       }
+                                       else if (param == -1 && PyErr_Occurred()) {
+                                               PyErr_Format(PyExc_TypeError,
+                                                            "%.200s: keyword \"%.200s\" expected an int, not %.200s",
+                                                            self->opname, slot_name, Py_TYPE(value)->tp_name);
+                                       }
+                                       else {
+                                               slot->data.i = (int)param;
+                                       }
+                                       break;
+                               }
+                               case BMO_OP_SLOT_FLT:
+                               {
+                                       float param = PyFloat_AsDouble(value);
+                                       if (param == -1 && PyErr_Occurred()) {
+                                               PyErr_Format(PyExc_TypeError,
+                                                            "%.200s: keyword \"%.200s\" expected a float, not %.200s",
+                                                            self->opname, slot_name, Py_TYPE(value)->tp_name);
+                                       }
+                                       else {
+                                               slot->data.f = param;
+                                       }
+                                       break;
+                               }
+                               case BMO_OP_SLOT_ELEMENT_BUF:
+                               {
+                                       /* there are many ways we could interpret arguments, for now...
+                                        * - verts/edges/faces from the mesh direct,
+                                        *   this way the operator takes every item.
+                                        * - `TODO` a plain python sequence (list) of elements.
+                                        * - `TODO`  an iterator. eg.
+                                        *   face.verts
+                                        * - `TODO`  (type, flag) pair, eg.
+                                        *   ('VERT', {'TAG'})
+                                        */
+
+#define BPY_BM_GENERIC_MESH_TEST(type_string)                                             \
+       if (((BPy_BMGeneric *)value)->bm != bm) {                                             \
+               PyErr_Format(PyExc_NotImplementedError,                                           \
+                                        "%.200s: keyword \"%.200s\" " type_string " are from another bmesh", \
+                                        self->opname, slot_name, slot->slot_type);                           \
+               return NULL;                                                                      \
        }
 
-       if (filter_edges != NULL && PyC_FlagSet_ToBitfield(bpy_bm_hflag_all_flags, filter_edges,
-                                                          &filter_edges_flags, "dissolve_limit") == -1)
-       {
-               return NULL;
+                                       if (BPy_BMVertSeq_Check(value)) {
+                                               BPY_BM_GENERIC_MESH_TEST("verts")
+                                               BMO_slot_buffer_from_all(bm, &bmop, slot_name, BM_VERT);
+                                       }
+                                       else if (BPy_BMEdgeSeq_Check(value)) {
+                                               BPY_BM_GENERIC_MESH_TEST("edges")
+                                               BMO_slot_buffer_from_all(bm, &bmop, slot_name, BM_EDGE);
+                                       }
+                                       else if (BPy_BMFaceSeq_Check(value)) {
+                                               BPY_BM_GENERIC_MESH_TEST("faces")
+                                               BMO_slot_buffer_from_all(bm, &bmop, slot_name, BM_FACE);
+                                       }
+                                       else if (BPy_BMElemSeq_Check(value)) {
+                                               BPY_BM_GENERIC_MESH_TEST("elements")
+
+                                               PyErr_Format(PyExc_NotImplementedError,
+                                                            "%.200s: keyword \"%.200s\" parsing element lists not working yet!",
+                                                            self->opname, slot_name, slot->slot_type);
+                                               return NULL;
+                                       }
+                                       else {
+                                               PyErr_Format(PyExc_TypeError,
+                                                            "%.200s: keyword \"%.200s\" expected "
+                                                            "a bmesh sequence, list, (htype, flag) pair, not %.200s",
+                                                            self->opname, slot_name, Py_TYPE(value)->tp_name);
+                                       }
+
+#undef BPY_BM_GENERIC_MESH_TEST
+
+                                       break;
+                               }
+                               default:
+                                       /* TODO --- many others */
+                                       PyErr_Format(PyExc_NotImplementedError,
+                                                    "%.200s: keyword \"%.200s\" type %d not working yet!",
+                                                    self->opname, slot_name, slot->slot_type);
+                                       return NULL;
+                                       break;
+                       }
+               }
        }
 
-       BMO_op_initf(bm, &bmop,
-                    "dissolve_limit verts=%hv edges=%he angle_limit=%f",
-                    filter_verts_flags, filter_edges_flags, angle_limit);
        BMO_op_exec(bm, &bmop);
        BMO_op_finish(bm, &bmop);
 
@@ -176,98 +251,225 @@ static PyObject *bpy_bm_ops_dissolve_limit(PyObject *UNUSED(self), PyObject *arg
                return NULL;
        }
 
-       /* TODO, return values */
        Py_RETURN_NONE;
 }
 
 
+PyTypeObject bmesh_op_Type = {
+       PyVarObject_HEAD_INIT(NULL, 0)
+       "BMeshOpFunc",              /* tp_name */
+       sizeof(BPy_BMeshOpFunc),    /* tp_basicsize */
+       0,                          /* tp_itemsize */
+       /* methods */
+       NULL,                       /* tp_dealloc */
+       NULL,                       /* printfunc tp_print; */
+       NULL,                       /* getattrfunc tp_getattr; */
+       NULL,                       /* setattrfunc tp_setattr; */
+       NULL,                       /* tp_compare */ /* DEPRECATED in python 3.0! */
+       (reprfunc) bpy_bmesh_op_repr, /* tp_repr */
+
+       /* Method suites for standard classes */
+
+       NULL,                       /* PyNumberMethods *tp_as_number; */
+       NULL,                       /* PySequenceMethods *tp_as_sequence; */
+       NULL,                       /* PyMappingMethods *tp_as_mapping; */
+
+       /* More standard operations (here for binary compatibility) */
+
+       NULL,                       /* hashfunc tp_hash; */
+       (ternaryfunc)pyrna_op_call, /* ternaryfunc tp_call; */
+       NULL,                       /* reprfunc tp_str; */
+
+       /* will only use these if this is a subtype of a py class */
+       NULL,                       /* getattrofunc tp_getattro; */
+       NULL,                       /* setattrofunc tp_setattro; */
+
+       /* Functions to access object as input/output buffer */
+       NULL,                       /* PyBufferProcs *tp_as_buffer; */
+
+       /*** Flags to define presence of optional/expanded features ***/
+       Py_TPFLAGS_DEFAULT,         /* long tp_flags; */
+
+       NULL,                       /*  char *tp_doc;  Documentation string */
+       /*** Assigned meaning in release 2.0 ***/
+       /* call function for all accessible objects */
+       NULL,                       /* traverseproc tp_traverse; */
+
+       /* delete references to contained objects */
+       NULL,                       /* inquiry tp_clear; */
+
+       /***  Assigned meaning in release 2.1 ***/
+       /*** rich comparisons ***/
+       NULL,                       /* richcmpfunc tp_richcompare; */
+
+       /***  weak reference enabler ***/
+       0,
+       /*** Added in release 2.2 ***/
+       /*   Iterators */
+       NULL,                       /* getiterfunc tp_iter; */
+       NULL,                       /* iternextfunc tp_iternext; */
+
+       /*** Attribute descriptor and subclassing stuff ***/
+       NULL,                       /* struct PyMethodDef *tp_methods; */
+       NULL,                       /* struct PyMemberDef *tp_members; */
+       NULL,                       /* struct PyGetSetDef *tp_getset; */
+       NULL,                       /* struct _typeobject *tp_base; */
+       NULL,                       /* PyObject *tp_dict; */
+       NULL,                       /* descrgetfunc tp_descr_get; */
+       NULL,                       /* descrsetfunc tp_descr_set; */
+       0,                          /* long tp_dictoffset; */
+       NULL,                       /* initproc tp_init; */
+       NULL,                       /* allocfunc tp_alloc; */
+       NULL,                       /* newfunc tp_new; */
+       /*  Low-level free-memory routine */
+       NULL,                       /* freefunc tp_free;  */
+       /* For PyObject_IS_GC */
+       NULL,                       /* inquiry tp_is_gc;  */
+       NULL,                       /* PyObject *tp_bases; */
+       /* method resolution order */
+       NULL,                       /* PyObject *tp_mro;  */
+       NULL,                       /* PyObject *tp_cache; */
+       NULL,                       /* PyObject *tp_subclasses; */
+       NULL,                       /* PyObject *tp_weaklist; */
+       NULL
+};
 
 
-PyDoc_STRVAR(bpy_bm_ops_remove_doubles_doc,
-".. method:: remove_doubles(bmesh, filter, dist)\n"
-"\n"
-"   Face split with optional intermediate points.\n"
-"\n"
-"   :arg bmesh: The face to cut.\n"
-"   :type bmesh: :class:`bmesh.types.BMFace`\n"
-"   :arg filter: Set containing vertex flags to apply the operator.\n"
-"   :type filter: set\n"
-"   :arg dist: Distance limit.\n"
-"   :type dist: float\n"
-);
-static PyObject *bpy_bm_ops_remove_doubles(PyObject *UNUSED(self), PyObject *args, PyObject *kw)
-{
-       static const char *kwlist[] = {"bmesh", "filter", "dist", NULL};
-
-       BPy_BMesh *py_bm;
-       BMesh *bm;
-
-       PyObject *filter;
-       int filter_flags;
-       float dist = 0.0f;
+/* bmesh fake module 'bmesh.ops'
+ * ***************************** */
 
-       BMOperator bmop;
+static PyObject *bpy_bmesh_fmod_getattro(PyObject *UNUSED(self), PyObject *pyname)
+{
+       const unsigned int tot = bmesh_total_ops;
+       unsigned int i;
+       const char *name = _PyUnicode_AsString(pyname);
 
-       if (!PyArg_ParseTupleAndKeywords(args, kw, "O!O!|f:remove_doubles", (char **)kwlist,
-                                        &BPy_BMesh_Type, &py_bm,
-                                        &PySet_Type,  &filter,
-                                        &dist))
-       {
-               return NULL;
+       for (i = 0; i < tot; i++) {
+               if (strcmp(opdefines[i]->name, name) == 0) {
+                       return bpy_bmesh_op_CreatePyObject(opdefines[i]->name);
+               }
        }
 
-       BPY_BM_CHECK_OBJ(py_bm);
-       bm = py_bm->bm;
+       PyErr_Format(PyExc_AttributeError,
+                    "BMeshOpsModule: , operator \"%.200s\" doesn't exist",
+                    name);
+       return NULL;
+}
 
-       if (filter != NULL && PyC_FlagSet_ToBitfield(bpy_bm_hflag_all_flags, filter,
-                                                    &filter_flags, "remove_doubles") == -1)
-       {
-               return NULL;
-       }
+static PyObject *bpy_bmesh_fmod_dir(PyObject *UNUSED(self))
+{
+       const unsigned int tot = bmesh_total_ops;
+       unsigned int i;
+       PyObject *ret;
 
-       BMO_op_initf(bm, &bmop,
-                    "remove_doubles verts=%hv dist=%f",
-                    filter_flags, dist);
-       BMO_op_exec(bm, &bmop);
-       BMO_op_finish(bm, &bmop);
+       ret = PyList_New(bmesh_total_ops);
 
-       if (bpy_bm_op_as_py_error(bm) == -1) {
-               return NULL;
+       for (i = 0; i < tot; i++) {
+               PyList_SET_ITEM(ret, i, PyUnicode_FromString(opdefines[i]->name));
        }
 
-       /* TODO, return values */
-       Py_RETURN_NONE;
+       return ret;
 }
 
-static struct PyMethodDef BPy_BM_ops_methods[] = {
-    {"convex_hull", (PyCFunction)bpy_bm_ops_convex_hull, METH_VARARGS | METH_KEYWORDS, bpy_bm_ops_convex_hull_doc},
-    {"dissolve_limit", (PyCFunction)bpy_bm_ops_dissolve_limit, METH_VARARGS | METH_KEYWORDS, bpy_bm_ops_dissolve_limit_doc},
-    {"remove_doubles", (PyCFunction)bpy_bm_ops_remove_doubles, METH_VARARGS | METH_KEYWORDS, bpy_bm_ops_remove_doubles_doc},
-    {NULL, NULL, 0, NULL}
+static struct PyMethodDef bpy_bmesh_fmod_methods[] = {
+       {"__dir__", (PyCFunction)bpy_bmesh_fmod_dir, METH_NOARGS, NULL},
+       {NULL, NULL, 0, NULL}
 };
 
-
-PyDoc_STRVAR(BPy_BM_ops_doc,
-             "This module provides access to bmesh operators (EXPEREMENTAL)."
-             );
-static struct PyModuleDef BPy_BM_ops_module_def = {
-    PyModuleDef_HEAD_INIT,
-    "bmesh.ops",  /* m_name */
-    BPy_BM_ops_doc,  /* m_doc */
-    0,  /* m_size */
-    BPy_BM_ops_methods,  /* m_methods */
-    NULL,  /* m_reload */
-    NULL,  /* m_traverse */
-    NULL,  /* m_clear */
-    NULL,  /* m_free */
+static PyTypeObject bmesh_ops_fakemod_Type = {
+       PyVarObject_HEAD_INIT(NULL, 0)
+       "BMeshOpsModule",           /* tp_name */
+       0,                          /* tp_basicsize */
+       0,                          /* tp_itemsize */
+       /* methods */
+       NULL,                       /* tp_dealloc */
+       NULL,                       /* printfunc tp_print; */
+       NULL,                       /* getattrfunc tp_getattr; */
+       NULL,                       /* setattrfunc tp_setattr; */
+       NULL,                       /* tp_compare */ /* DEPRECATED in python 3.0! */
+       NULL,                       /* tp_repr */
+
+       /* Method suites for standard classes */
+
+       NULL,                       /* PyNumberMethods *tp_as_number; */
+       NULL,                       /* PySequenceMethods *tp_as_sequence; */
+       NULL,                       /* PyMappingMethods *tp_as_mapping; */
+
+       /* More standard operations (here for binary compatibility) */
+
+       NULL,                       /* hashfunc tp_hash; */
+       NULL,                       /* ternaryfunc tp_call; */
+       NULL,                       /* reprfunc tp_str; */
+
+       /* will only use these if this is a subtype of a py class */
+       bpy_bmesh_fmod_getattro,    /* getattrofunc tp_getattro; */
+       NULL,                       /* setattrofunc tp_setattro; */
+
+       /* Functions to access object as input/output buffer */
+       NULL,                       /* PyBufferProcs *tp_as_buffer; */
+
+       /*** Flags to define presence of optional/expanded features ***/
+       Py_TPFLAGS_DEFAULT,         /* long tp_flags; */
+
+       NULL,                       /*  char *tp_doc;  Documentation string */
+       /*** Assigned meaning in release 2.0 ***/
+       /* call function for all accessible objects */
+       NULL,                       /* traverseproc tp_traverse; */
+
+       /* delete references to contained objects */
+       NULL,                       /* inquiry tp_clear; */
+
+       /***  Assigned meaning in release 2.1 ***/
+       /*** rich comparisons ***/
+       NULL, /* subclassed */          /* richcmpfunc tp_richcompare; */
+
+       /***  weak reference enabler ***/
+       0,
+       /*** Added in release 2.2 ***/
+       /*   Iterators */
+       NULL,                       /* getiterfunc tp_iter; */
+       NULL,                       /* iternextfunc tp_iternext; */
+
+       /*** Attribute descriptor and subclassing stuff ***/
+       bpy_bmesh_fmod_methods,  /* struct PyMethodDef *tp_methods; */
+       NULL,                       /* struct PyMemberDef *tp_members; */
+       NULL,                       /* struct PyGetSetDef *tp_getset; */
+       NULL,                       /* struct _typeobject *tp_base; */
+       NULL,                       /* PyObject *tp_dict; */
+       NULL,                       /* descrgetfunc tp_descr_get; */
+       NULL,                       /* descrsetfunc tp_descr_set; */
+       0,                          /* long tp_dictoffset; */
+       NULL,                       /* initproc tp_init; */
+       NULL,                       /* allocfunc tp_alloc; */
+       NULL,                       /* newfunc tp_new; */
+       /*  Low-level free-memory routine */
+       NULL,                       /* freefunc tp_free;  */
+       /* For PyObject_IS_GC */
+       NULL,                       /* inquiry tp_is_gc;  */
+       NULL,                       /* PyObject *tp_bases; */
+       /* method resolution order */
+       NULL,                       /* PyObject *tp_mro;  */
+       NULL,                       /* PyObject *tp_cache; */
+       NULL,                       /* PyObject *tp_subclasses; */
+       NULL,                       /* PyObject *tp_weaklist; */
+       NULL
 };
 
-
 PyObject *BPyInit_bmesh_ops(void)
 {
        PyObject *submodule;
 
-       submodule = PyModule_Create(&BPy_BM_ops_module_def);
+       if (PyType_Ready(&bmesh_ops_fakemod_Type) < 0)
+               return NULL;
+
+       if (PyType_Ready(&bmesh_op_Type) < 0)
+               return NULL;
+
+       submodule = PyObject_New(PyObject, &bmesh_ops_fakemod_Type);
+
+       /* prevent further creation of instances */
+       bmesh_ops_fakemod_Type.tp_init = NULL;
+       bmesh_ops_fakemod_Type.tp_new = NULL;
 
        return submodule;
 }