Index: interfaces/python/aubio-types.h
===================================================================
--- interfaces/python/aubio-types.h	(revision 7a7b00f3a3d6681b34287a8e94d5314cd6ae2c0e)
+++ interfaces/python/aubio-types.h	(revision 96fe713cccdf01faf343d5ac629381d9348fca68)
@@ -6,6 +6,6 @@
 #include <aubio.h>
 
-#define Py_default_vector_length   1024
-#define Py_default_vector_channels 1
+#define Py_default_vector_length 1024
+#define Py_default_vector_height 1
 
 #define Py_aubio_default_samplerate 44100
@@ -25,5 +25,4 @@
 
 */
-#define AUBIO_DO_CASTING 0
 
 typedef struct
@@ -32,5 +31,4 @@
   fvec_t * o;
   uint_t length;
-  uint_t channels;
 } Py_fvec;
 extern PyTypeObject Py_fvecType;
@@ -38,4 +36,16 @@
 extern PyObject *PyAubio_CFvecToArray (fvec_t * self);
 extern Py_fvec *PyAubio_ArrayToFvec (PyObject * self);
+
+typedef struct
+{
+  PyObject_HEAD
+  fmat_t * o;
+  uint_t length;
+  uint_t height;
+} Py_fmat;
+extern PyTypeObject Py_fmatType;
+extern PyObject *PyAubio_FmatToArray (Py_fmat * self);
+extern PyObject *PyAubio_CFmatToArray (fmat_t * self);
+extern Py_fmat *PyAubio_ArrayToFmat (PyObject * self);
 
 typedef struct
Index: interfaces/python/aubiomodule.c
===================================================================
--- interfaces/python/aubiomodule.c	(revision 7a7b00f3a3d6681b34287a8e94d5314cd6ae2c0e)
+++ interfaces/python/aubiomodule.c	(revision 96fe713cccdf01faf343d5ac629381d9348fca68)
@@ -122,4 +122,5 @@
 
   if ((PyType_Ready (&Py_fvecType) < 0) 
+      || (PyType_Ready (&Py_fmatType) < 0) 
       || (PyType_Ready (&Py_cvecType) < 0) 
       || (PyType_Ready (&Py_filterType) < 0) 
@@ -148,4 +149,6 @@
   Py_INCREF (&Py_fvecType);
   PyModule_AddObject (m, "fvec", (PyObject *) & Py_fvecType);
+  Py_INCREF (&Py_fmatType);
+  PyModule_AddObject (m, "fmat", (PyObject *) & Py_fmatType);
   Py_INCREF (&Py_cvecType);
   PyModule_AddObject (m, "cvec", (PyObject *) & Py_cvecType);
Index: interfaces/python/aubiowraphell.h
===================================================================
--- interfaces/python/aubiowraphell.h	(revision 7a7b00f3a3d6681b34287a8e94d5314cd6ae2c0e)
+++ interfaces/python/aubiowraphell.h	(revision 96fe713cccdf01faf343d5ac629381d9348fca68)
@@ -94,6 +94,5 @@
 
 // some more helpers
-#define AUBIO_NEW_VEC(name, type, lengthval, channelsval) \
+#define AUBIO_NEW_VEC(name, type, lengthval) \
   name = (type *) PyObject_New (type, & type ## Type); \
-  name->channels = channelsval; \
   name->length = lengthval;
Index: interfaces/python/gen_pyobject.py
===================================================================
--- interfaces/python/gen_pyobject.py	(revision 7a7b00f3a3d6681b34287a8e94d5314cd6ae2c0e)
+++ interfaces/python/gen_pyobject.py	(revision 96fe713cccdf01faf343d5ac629381d9348fca68)
@@ -69,18 +69,18 @@
 # move into the C library at some point.
 defaultsizes = {
-    'resampler':    ('input->length * self->ratio', 'input->channels'),
-    'specdesc':     ('1', 'fftgrain->channels'),
-    'onset':        ('1', 'self->channels'),
-    'pitchyin':     ('1', 'in->channels'),
-    'pitchyinfft':  ('1', 'in->channels'),
-    'pitchschmitt': ('1', 'in->channels'),
-    'pitchmcomb':   ('1', 'self->channels'),
-    'pitchfcomb':   ('1', 'self->channels'),
-    'pitch':        ('1', 'self->channels'),
-    'tss':          ('self->hop_size', 'self->channels'),
-    'mfcc':         ('self->n_coeffs', 'in->channels'),
-    'beattracking': ('self->hop_size', 'self->channels'),
-    'tempo':        ('1', 'self->channels'),
-    'peakpicker':   ('1', 'self->channels'),
+    'resampler':    'input->length * self->ratio',
+    'specdesc':     '1',
+    'onset':        '1',
+    'pitchyin':     '1',
+    'pitchyinfft':  '1',
+    'pitchschmitt': '1',
+    'pitchmcomb':   '1',
+    'pitchfcomb':   '1',
+    'pitch':        '1',
+    'tss':          'self->hop_size',
+    'mfcc':         'self->n_coeffs',
+    'beattracking': 'self->hop_size',
+    'tempo':        '1',
+    'peakpicker':   '1',
 }
 
@@ -99,5 +99,4 @@
     'hop_size': 'Py_default_vector_length / 2', 
     # these should be alright
-    'channels': 'Py_default_vector_channels', 
     'samplerate': 'Py_aubio_default_samplerate', 
     # now for the non obvious ones
@@ -151,5 +150,8 @@
     newparams = get_params_types_names(newfunc)
     # self->param1, self->param2, self->param3
-    selfparams = ', self->'.join([p[1] for p in newparams])
+    if len(newparams):
+        selfparams = ', self->'+', self->'.join([p[1] for p in newparams])
+    else:
+        selfparams = '' 
     # "param1", "param2", "param3"
     paramnames = ", ".join(["\""+p[1]+"\"" for p in newparams])
@@ -179,4 +181,5 @@
 Py_%(name)s_new (PyTypeObject * pytype, PyObject * args, PyObject * kwds)
 {
+  Py_%(name)s *self;
 """ % locals()
     for ptype, pname in newparams:
@@ -186,6 +189,6 @@
 """ % locals()
     # now the actual PyArg_Parse
-    s += """\
-  Py_%(name)s *self;
+    if len(paramnames):
+        s += """\
   static char *kwlist[] = { %(paramnames)s, NULL };
 
@@ -194,4 +197,6 @@
     return NULL;
   }
+""" % locals()
+    s += """\
 
   self = (Py_%(name)s *) pytype->tp_alloc (pytype, 0);
@@ -238,5 +243,5 @@
 }
 
-AUBIO_INIT(%(name)s, self->%(selfparams)s)
+AUBIO_INIT(%(name)s %(selfparams)s)
 
 AUBIO_DEL(%(name)s)
@@ -287,8 +292,8 @@
         outputvecs = "\n  ".join([aubio2pyaubio[p[0]]+" * " + p[-1] + ";" for p in outputparams])
         outputcreate = "\n  ".join(["""\
-AUBIO_NEW_VEC(%(name)s, %(pytype)s, %(length)s, %(channels)s)
-  %(name)s->o = new_%(autype)s (%(length)s, %(channels)s);""" % \
+AUBIO_NEW_VEC(%(name)s, %(pytype)s, %(length)s)
+  %(name)s->o = new_%(autype)s (%(length)s);""" % \
     {'name': p[-1], 'pytype': aubio2pyaubio[p[0]], 'autype': p[0][:-3],
-        'length': defaultsizes[name][0], 'channels': defaultsizes[name][1]} \
+        'length': defaultsizes[name]} \
         for p in outputparams]) 
         if len(outputparams) > 1:
Index: interfaces/python/py-fft.c
===================================================================
--- interfaces/python/py-fft.c	(revision 7a7b00f3a3d6681b34287a8e94d5314cd6ae2c0e)
+++ interfaces/python/py-fft.c	(revision 96fe713cccdf01faf343d5ac629381d9348fca68)
@@ -3,5 +3,5 @@
 static char Py_fft_doc[] = "fft object";
 
-AUBIO_DECLARE(fft, uint_t win_s; uint_t channels)
+AUBIO_DECLARE(fft, uint_t win_s)
 
 //AUBIO_NEW(fft)
@@ -9,10 +9,10 @@
 Py_fft_new (PyTypeObject * type, PyObject * args, PyObject * kwds)
 {
-  int win_s = 0, channels = 0;
+  int win_s = 0;
   Py_fft *self;
-  static char *kwlist[] = { "win_s", "channels", NULL };
+  static char *kwlist[] = { "win_s", NULL };
 
-  if (!PyArg_ParseTupleAndKeywords (args, kwds, "|II", kwlist,
-          &win_s, &channels)) {
+  if (!PyArg_ParseTupleAndKeywords (args, kwds, "|I", kwlist,
+          &win_s)) {
     return NULL;
   }
@@ -25,5 +25,4 @@
 
   self->win_s = Py_default_vector_length;
-  self->channels = Py_default_vector_channels;
 
   if (self == NULL) {
@@ -39,17 +38,9 @@
   }
 
-  if (channels > 0) {
-    self->channels = channels;
-  } else if (channels < 0) {
-    PyErr_SetString (PyExc_ValueError,
-        "can not use negative number of filters");
-    return NULL;
-  }
-
   return (PyObject *) self;
 }
 
 
-AUBIO_INIT(fft, self->win_s, self->channels)
+AUBIO_INIT(fft, self->win_s)
 
 AUBIO_DEL(fft)
@@ -73,7 +64,6 @@
 
   output = (Py_cvec*) PyObject_New (Py_cvec, &Py_cvecType);
-  output->channels = vec->channels;
   output->length = ((Py_fft *) self)->win_s;
-  output->o = new_cvec(((Py_fft *) self)->win_s, vec->channels);
+  output->o = new_cvec(((Py_fft *) self)->win_s);
 
   // compute the function
@@ -87,6 +77,4 @@
   {"win_s", T_INT, offsetof (Py_fft, win_s), READONLY,
     "size of the window"},
-  {"channels", T_INT, offsetof (Py_fft, channels), READONLY,
-    "number of channels"},
 AUBIO_MEMBERS_STOP(fft)
 
@@ -109,7 +97,6 @@
 
   output = (Py_fvec*) PyObject_New (Py_fvec, &Py_fvecType);
-  output->channels = vec->channels;
   output->length = ((Py_fft *) self)->win_s;
-  output->o = new_fvec(output->length, output->channels);
+  output->o = new_fvec(output->length);
 
   // compute the function
Index: interfaces/python/py-filter.c
===================================================================
--- interfaces/python/py-filter.c	(revision 7a7b00f3a3d6681b34287a8e94d5314cd6ae2c0e)
+++ interfaces/python/py-filter.c	(revision 96fe713cccdf01faf343d5ac629381d9348fca68)
@@ -6,5 +6,4 @@
   aubio_filter_t * o;
   uint_t order;
-  uint_t channels;
 } Py_filter;
 
@@ -14,10 +13,10 @@
 Py_filter_new (PyTypeObject * type, PyObject * args, PyObject * kwds)
 {
-  int order= 0, channels = 0;
+  int order= 0;
   Py_filter *self;
-  static char *kwlist[] = { "order", "channels", NULL };
+  static char *kwlist[] = { "order", NULL };
 
   if (!PyArg_ParseTupleAndKeywords (args, kwds, "|II", kwlist,
-          &order, &channels)) {
+          &order)) {
     return NULL;
   }
@@ -30,5 +29,4 @@
 
   self->order = 7;
-  self->channels = Py_default_vector_channels;
 
   if (order > 0) {
@@ -40,12 +38,4 @@
   }
 
-  if (channels > 0) {
-    self->channels = channels;
-  } else if (channels < 0) {
-    PyErr_SetString (PyExc_ValueError,
-        "can not use negative number of channels");
-    return NULL;
-  }
-
   return (PyObject *) self;
 }
@@ -54,5 +44,5 @@
 Py_filter_init (Py_filter * self, PyObject * args, PyObject * kwds)
 {
-  self->o = new_aubio_filter (self->order, self->channels);
+  self->o = new_aubio_filter (self->order);
   if (self->o == NULL) {
     return -1;
@@ -92,9 +82,9 @@
 #if 1
   aubio_filter_do (((Py_filter *)self)->o, vec->o);
-  Py_INCREF(vec);
+  PyArray_INCREF((PyArrayObject*)vec);
   return (PyObject *)vec;
 #else
   Py_fvec *copy = (Py_fvec*) PyObject_New (Py_fvec, &Py_fvecType);
-  copy->o = new_fvec(vec->o->length, vec->o->channels);
+  copy->o = new_fvec(vec->o->length);
   aubio_filter_do_outplace (((Py_filter *)self)->o, vec->o, copy->o);
   return (PyObject *)copy;
@@ -142,6 +132,4 @@
   {"order", T_INT, offsetof (Py_filter, order), READONLY,
       "order of the filter"},
-  {"channels", T_INT, offsetof (Py_filter, channels), READONLY,
-      "number of channels"},
   {NULL}                        /* Sentinel */
 };
Index: interfaces/python/py-filterbank.c
===================================================================
--- interfaces/python/py-filterbank.c	(revision 7a7b00f3a3d6681b34287a8e94d5314cd6ae2c0e)
+++ interfaces/python/py-filterbank.c	(revision 96fe713cccdf01faf343d5ac629381d9348fca68)
@@ -68,7 +68,6 @@
 
   output = (Py_fvec*) PyObject_New (Py_fvec, &Py_fvecType);
-  output->channels = vec->channels;
   output->length = self->n_filters;
-  output->o = new_fvec(self->n_filters, vec->channels);
+  output->o = new_fvec(self->n_filters);
 
   // compute the function
@@ -138,9 +137,7 @@
 Py_filterbank_get_coeffs (Py_filterbank * self, PyObject *unused)
 {
-  Py_fvec *output = (Py_fvec *) PyObject_New (Py_fvec, &Py_fvecType);
-  output->channels = self->n_filters;
-  output->length = self->win_s / 2 + 1;
+  Py_fmat *output = (Py_fmat *) PyObject_New (Py_fmat, &Py_fvecType);
   output->o = aubio_filterbank_get_coeffs (self->o);
-  return (PyObject *)PyAubio_FvecToArray(output);
+  return (PyObject *)PyAubio_FmatToArray(output);
 }
 
Index: interfaces/python/py-fmat.c
===================================================================
--- interfaces/python/py-fmat.c	(revision 96fe713cccdf01faf343d5ac629381d9348fca68)
+++ interfaces/python/py-fmat.c	(revision 96fe713cccdf01faf343d5ac629381d9348fca68)
@@ -0,0 +1,332 @@
+#include "aubio-types.h"
+
+/* fmat type definition 
+
+class fmat():
+    def __init__(self, length = 1024, height = 1):
+        self.length = length 
+        self.height = height 
+        self.data = array(length, height)
+
+*/
+
+static char Py_fmat_doc[] = "fmat object";
+
+static PyObject *
+Py_fmat_new (PyTypeObject * type, PyObject * args, PyObject * kwds)
+{
+  int length= 0, height = 0;
+  Py_fmat *self;
+  static char *kwlist[] = { "length", "height", NULL };
+
+  if (!PyArg_ParseTupleAndKeywords (args, kwds, "|II", kwlist,
+          &length, &height)) {
+    return NULL;
+  }
+
+
+  self = (Py_fmat *) type->tp_alloc (type, 0);
+
+  self->length = Py_default_vector_length;
+  self->height = Py_default_vector_height;
+
+  if (self == NULL) {
+    return NULL;
+  }
+
+  if (length > 0) {
+    self->length = length;
+  } else if (length < 0) {
+    PyErr_SetString (PyExc_ValueError,
+        "can not use negative number of elements");
+    return NULL;
+  }
+
+  if (height > 0) {
+    self->height = height;
+  } else if (height < 0) {
+    PyErr_SetString (PyExc_ValueError,
+        "can not use negative number of height");
+    return NULL;
+  }
+
+  return (PyObject *) self;
+}
+
+static int
+Py_fmat_init (Py_fmat * self, PyObject * args, PyObject * kwds)
+{
+  self->o = new_fmat (self->length, self->height);
+  if (self->o == NULL) {
+    return -1;
+  }
+
+  return 0;
+}
+
+static void
+Py_fmat_del (Py_fmat * self)
+{
+  del_fmat (self->o);
+  self->ob_type->tp_free ((PyObject *) self);
+}
+
+static PyObject *
+Py_fmat_repr (Py_fmat * self, PyObject * unused)
+{
+  PyObject *format = NULL;
+  PyObject *args = NULL;
+  PyObject *result = NULL;
+
+  format = PyString_FromString ("aubio fmat of %d elements with %d height");
+  if (format == NULL) {
+    goto fail;
+  }
+
+  args = Py_BuildValue ("II", self->length, self->height);
+  if (args == NULL) {
+    goto fail;
+  }
+  fmat_print ( self->o );
+
+  result = PyString_Format (format, args);
+
+fail:
+  Py_XDECREF (format);
+  Py_XDECREF (args);
+
+  return result;
+}
+
+Py_fmat *
+PyAubio_ArrayTofmat (PyObject *input) {
+  PyObject *array;
+  Py_fmat *vec;
+  uint_t i;
+  if (input == NULL) {
+    PyErr_SetString (PyExc_ValueError, "input array is not a python object");
+    goto fail;
+  }
+  // parsing input object into a Py_fmat
+  if (PyObject_TypeCheck (input, &Py_fmatType)) {
+    // input is an fmat, nothing else to do
+    vec = (Py_fmat *) input;
+  } else if (PyArray_Check(input)) {
+
+    // we got an array, convert it to an fmat 
+    if (PyArray_NDIM (input) == 0) {
+      PyErr_SetString (PyExc_ValueError, "input array is a scalar");
+      goto fail;
+    } else if (PyArray_NDIM (input) > 2) {
+      PyErr_SetString (PyExc_ValueError,
+          "input array has more than two dimensions");
+      goto fail;
+    }
+
+    if (!PyArray_ISFLOAT (input)) {
+      PyErr_SetString (PyExc_ValueError, "input array should be float");
+      goto fail;
+    } else if (PyArray_TYPE (input) != AUBIO_NPY_SMPL) {
+      PyErr_SetString (PyExc_ValueError, "input array should be float32");
+      goto fail;
+    } else {
+      // input data type is float32, nothing else to do
+      array = input;
+    }
+
+    // create a new fmat object
+    vec = (Py_fmat*) PyObject_New (Py_fmat, &Py_fmatType); 
+    if (PyArray_NDIM (array) == 1) {
+      vec->height = 1;
+      vec->length = PyArray_SIZE (array);
+    } else {
+      vec->height = PyArray_DIM (array, 0);
+      vec->length = PyArray_DIM (array, 1);
+    }
+
+    // no need to really allocate fmat, just its struct member 
+    // vec->o = new_fmat (vec->length, vec->height);
+    vec->o = (fmat_t *)malloc(sizeof(fmat_t));
+    vec->o->length = vec->length; vec->o->height = vec->height;
+    vec->o->data = (smpl_t**)malloc(vec->o->height * sizeof(smpl_t*));
+    // hat data[i] point to array line
+    for (i = 0; i < vec->height; i++) {
+      vec->o->data[i] = (smpl_t *) PyArray_GETPTR1 (array, i);
+    }
+
+  } else {
+    PyErr_SetString (PyExc_ValueError, "can only accept array or fmat as input");
+    return NULL;
+  }
+
+  return vec;
+
+fail:
+  return NULL;
+}
+
+PyObject *
+PyAubio_CfmatToArray (fmat_t * self)
+{
+  PyObject *array = NULL;
+  uint_t i;
+  npy_intp dims[] = { self->length, 1 };
+  PyObject *concat = PyList_New (0), *tmp = NULL;
+  for (i = 0; i < self->height; i++) {
+    tmp = PyArray_SimpleNewFromData (1, dims, AUBIO_NPY_SMPL, self->data[i]);
+    PyList_Append (concat, tmp);
+    Py_DECREF (tmp);
+  }
+  array = PyArray_FromObject (concat, AUBIO_NPY_SMPL, 2, 2);
+  Py_DECREF (concat);
+  return array;
+}
+
+PyObject *
+PyAubio_FmatToArray (Py_fmat * self)
+{
+  PyObject *array = NULL;
+  if (self->height == 1) {
+    npy_intp dims[] = { self->length, 1 };
+    array = PyArray_SimpleNewFromData (1, dims, AUBIO_NPY_SMPL, self->o->data[0]);
+  } else {
+    uint_t i;
+    npy_intp dims[] = { self->length, 1 };
+    PyObject *concat = PyList_New (0), *tmp = NULL;
+    for (i = 0; i < self->height; i++) {
+      tmp = PyArray_SimpleNewFromData (1, dims, AUBIO_NPY_SMPL, self->o->data[i]);
+      PyList_Append (concat, tmp);
+      Py_DECREF (tmp);
+    }
+    array = PyArray_FromObject (concat, AUBIO_NPY_SMPL, 2, 2);
+    Py_DECREF (concat);
+  }
+  return array;
+}
+
+static Py_ssize_t
+Py_fmat_get_height (Py_fmat * self)
+{
+  return self->height;
+}
+
+static PyObject *
+Py_fmat_getitem (Py_fmat * self, Py_ssize_t index)
+{
+  PyObject *array;
+
+  if (index < 0 || index >= self->height) {
+    PyErr_SetString (PyExc_IndexError, "no such channel");
+    return NULL;
+  }
+
+  npy_intp dims[] = { self->length, 1 };
+  array = PyArray_SimpleNewFromData (1, dims, AUBIO_NPY_SMPL, self->o->data[index]);
+  return array;
+}
+
+static int
+Py_fmat_setitem (Py_fmat * self, Py_ssize_t index, PyObject * o)
+{
+  PyObject *array;
+
+  if (index < 0 || index >= self->height) {
+    PyErr_SetString (PyExc_IndexError, "no such channel");
+    return -1;
+  }
+
+  array = PyArray_FROM_OT (o, AUBIO_NPY_SMPL);
+  if (array == NULL) {
+    PyErr_SetString (PyExc_ValueError, "should be an array of float");
+    goto fail;
+  }
+
+  if (PyArray_NDIM (array) != 1) {
+    PyErr_SetString (PyExc_ValueError, "should be a one-dimensional array");
+    goto fail;
+  }
+
+  if (PyArray_SIZE (array) != self->length) {
+    PyErr_SetString (PyExc_ValueError,
+        "should be an array of same length as target fmat");
+    goto fail;
+  }
+
+  self->o->data[index] = (smpl_t *) PyArray_GETPTR1 (array, 0);
+
+  return 0;
+
+fail:
+  return -1;
+}
+
+static PyMemberDef Py_fmat_members[] = {
+  // TODO remove READONLY flag and define getter/setter
+  {"length", T_INT, offsetof (Py_fmat, length), READONLY,
+      "length attribute"},
+  {"height", T_INT, offsetof (Py_fmat, height), READONLY,
+      "height attribute"},
+  {NULL}                        /* Sentinel */
+};
+
+static PyMethodDef Py_fmat_methods[] = {
+  {"__array__", (PyCFunction) PyAubio_FmatToArray, METH_NOARGS,
+      "Returns the vector as a numpy array."},
+  {NULL}
+};
+
+static PySequenceMethods Py_fmat_tp_as_sequence = {
+  (lenfunc) Py_fmat_get_height,        /* sq_length         */
+  0,                                    /* sq_concat         */
+  0,                                    /* sq_repeat         */
+  (ssizeargfunc) Py_fmat_getitem,       /* sq_item           */
+  0,                                    /* sq_slice          */
+  (ssizeobjargproc) Py_fmat_setitem,    /* sq_ass_item       */
+  0,                                    /* sq_ass_slice      */
+  0,                                    /* sq_contains       */
+  0,                                    /* sq_inplace_concat */
+  0,                                    /* sq_inplace_repeat */
+};
+
+
+PyTypeObject Py_fmatType = {
+  PyObject_HEAD_INIT (NULL)
+  0,                            /* ob_size           */
+  "aubio.fmat",                 /* tp_name           */
+  sizeof (Py_fmat),             /* tp_basicsize      */
+  0,                            /* tp_itemsize       */
+  (destructor) Py_fmat_del,     /* tp_dealloc        */
+  0,                            /* tp_print          */
+  0,                            /* tp_getattr        */
+  0,                            /* tp_setattr        */
+  0,                            /* tp_compare        */
+  (reprfunc) Py_fmat_repr,      /* tp_repr           */
+  0,                            /* tp_as_number      */
+  &Py_fmat_tp_as_sequence,      /* 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,           /* tp_flags          */
+  Py_fmat_doc,                  /* tp_doc            */
+  0,                            /* tp_traverse       */
+  0,                            /* tp_clear          */
+  0,                            /* tp_richcompare    */
+  0,                            /* tp_weaklistoffset */
+  0,                            /* tp_iter           */
+  0,                            /* tp_iternext       */
+  Py_fmat_methods,              /* tp_methods        */
+  Py_fmat_members,              /* tp_members        */
+  0,                            /* tp_getset         */
+  0,                            /* tp_base           */
+  0,                            /* tp_dict           */
+  0,                            /* tp_descr_get      */
+  0,                            /* tp_descr_set      */
+  0,                            /* tp_dictoffset     */
+  (initproc) Py_fmat_init,      /* tp_init           */
+  0,                            /* tp_alloc          */
+  Py_fmat_new,                  /* tp_new            */
+};
