source: python/lib/gen_code.py @ bbc62b5

feature/autosinkfeature/constantqfeature/pitchshiftfeature/pydocstringsfeature/timestretchpitchshiftsamplertimestretchyinfft+
Last change on this file since bbc62b5 was bbc62b5, checked in by Paul Brossier <piem@piem.org>, 4 years ago

python/lib/gen_code.py: fix format string

  • Property mode set to 100644
File size: 16.0 KB
Line 
1aubiodefvalue = {
2    # we have some clean up to do
3    'buf_size': 'Py_default_vector_length',
4    'win_s': 'Py_default_vector_length',
5    # and here too
6    'hop_size': 'Py_default_vector_length / 2',
7    'hop_s': 'Py_default_vector_length / 2',
8    # these should be alright
9    'samplerate': 'Py_aubio_default_samplerate',
10    # now for the non obvious ones
11    'n_filters': '40',
12    'n_coeffs': '13',
13    'nelems': '10',
14    'flow': '0.',
15    'fhig': '1.',
16    'ilow': '0.',
17    'ihig': '1.',
18    'thrs': '0.5',
19    'ratio': '0.5',
20    'method': '"default"',
21    'uri': '"none"',
22    }
23
24member_types = {
25        'name': 'type',
26        'char_t*': 'T_STRING',
27        'uint_t': 'T_INT',
28        'smpl_t': 'AUBIO_NPY_SMPL',
29        }
30
31pyfromtype_fn = {
32        'smpl_t': 'PyFloat_FromDouble',
33        'uint_t': 'PyLong_FromLong', # was: 'PyInt_FromLong',
34        'fvec_t*': 'PyAubio_CFvecToArray',
35        'fmat_t*': 'PyAubio_CFmatToArray',
36        }
37
38pytoaubio_fn = {
39        'fvec_t*': 'PyAubio_ArrayToCFvec',
40        'cvec_t*': 'PyAubio_PyCvecToCCvec',
41        #'fmat_t*': 'PyAubio_ArrayToCFmat',
42        }
43
44pyfromaubio_fn = {
45        'fvec_t*': 'PyAubio_CFvecToArray',
46        'cvec_t*': 'PyAubio_CCvecToArray',
47        'fmat_t*': 'PyAubio_CFmatToArray',
48        }
49
50newfromtype_fn = {
51        'fvec_t*': 'new_py_fvec',
52        'fmat_t*': 'new_py_fmat',
53        'cvec_t*': 'new_py_cvec',
54        }
55
56delfromtype_fn = {
57        'fvec_t*': 'Py_DECREF',
58        'fmat_t*': 'Py_DECREF',
59        'cvec_t*': 'Py_DECREF',
60        }
61
62param_init = {
63        'char_t*': 'NULL',
64        'uint_t': '0',
65        'sint_t': 0,
66        'smpl_t': 0.,
67        'lsmp_t': 0.,
68        }
69
70pyargparse_chars = {
71        'smpl_t': 'f', # if not usedouble else 'd',
72        'uint_t': 'I',
73        'sint_t': 'I',
74        'char_t*': 's',
75        'fmat_t*': 'O',
76        'fvec_t*': 'O',
77        'cvec_t*': 'O',
78        }
79
80objoutsize = {
81        'onset': '1',
82        'pitch': '1',
83        'wavetable': 'self->hop_size',
84        'sampler': 'self->hop_size',
85        'mfcc': 'self->n_coeffs',
86        'specdesc': '1',
87        'tempo': '1',
88        'filterbank': 'self->n_filters',
89        'tss': 'self->hop_size',
90        }
91
92def get_name(proto):
93    name = proto.replace(' *', '* ').split()[1].split('(')[0]
94    name = name.replace('*','')
95    if name == '': raise ValueError(proto + "gave empty name")
96    return name
97
98def get_return_type(proto):
99    import re
100    paramregex = re.compile('(\w+ ?\*?).*')
101    outputs = paramregex.findall(proto)
102    assert len(outputs) == 1
103    return outputs[0].replace(' ', '')
104
105def split_type(arg):
106    """ arg = 'foo *name'
107        return ['foo*', 'name'] """
108    l = arg.split()
109    type_arg = {} #'type': l[0], 'name': l[1]}
110    type_arg['type'] = " ".join(l[:-1])
111    type_arg['name'] = l[-1]
112    # fix up type / name
113    if type_arg['name'].startswith('*'):
114        # ['foo', '*name'] -> ['foo*', 'name']
115        type_arg['type'] += '*'
116        type_arg['name'] = type_arg['name'][1:]
117    if type_arg['type'].endswith(' *'):
118        # ['foo *', 'name'] -> ['foo*', 'name']
119        type_arg['type'] = type_arg['type'].replace(' *','*')
120    if type_arg['type'].startswith('const '):
121        # ['foo *', 'name'] -> ['foo*', 'name']
122        type_arg['type'] = type_arg['type'].replace('const ','')
123    return type_arg
124
125def get_params(proto):
126    """ get the list of parameters from a function prototype
127    example: proto = "int main (int argc, char ** argv)"
128    returns: ['int argc', 'char ** argv']
129    """
130    import re
131    paramregex = re.compile('.*\((.*)\);')
132    a = paramregex.findall(proto)[0].split(', ')
133    #a = [i.replace('const ', '') for i in a]
134    return a
135
136def get_input_params(proto):
137    a = get_params(proto)
138    return [i.replace('const ', '') for i in a if (i.startswith('const ') or i.startswith('uint_t ') or i.startswith('smpl_t '))]
139
140def get_output_params(proto):
141    a = get_params(proto)
142    return [i for i in a if not i.startswith('const ')][1:]
143
144def get_params_types_names(proto):
145    """ get the list of parameters from a function prototype
146    example: proto = "int main (int argc, char ** argv)"
147    returns: [['int', 'argc'], ['char **','argv']]
148    """
149    a = list(map(split_type, get_params(proto)))
150    #print proto, a
151    #import sys; sys.exit(1)
152    return a
153
154class MappedObject(object):
155
156    def __init__(self, prototypes, usedouble = False):
157        if usedouble:
158            pyargparse_chars['smpl_t'] = 'd'
159        self.prototypes = prototypes
160
161        self.shortname = prototypes['shortname']
162        self.longname = prototypes['longname']
163        self.new_proto = prototypes['new'][0]
164        self.del_proto = prototypes['del'][0]
165        self.do_proto = prototypes['do'][0]
166        self.input_params = get_params_types_names(self.new_proto)
167        self.input_params_list = "; ".join(get_input_params(self.new_proto))
168        self.outputs = get_params_types_names(self.do_proto)[2:]
169        self.do_inputs = [get_params_types_names(self.do_proto)[1]]
170        self.do_outputs = get_params_types_names(self.do_proto)[2:]
171        struct_output_str = ["PyObject *{0[name]}; {1} c_{0[name]}".format(i, i['type'][:-1]) for i in self.do_outputs]
172        self.struct_outputs = ";\n    ".join(struct_output_str)
173
174        #print ("input_params: ", map(split_type, get_input_params(self.do_proto)))
175        #print ("output_params", map(split_type, get_output_params(self.do_proto)))
176
177    def gen_code(self):
178        out = ""
179        out += self.gen_struct()
180        out += self.gen_doc()
181        out += self.gen_new()
182        out += self.gen_init()
183        out += self.gen_del()
184        out += self.gen_do()
185        out += self.gen_memberdef()
186        out += self.gen_set()
187        out += self.gen_get()
188        out += self.gen_methodef()
189        out += self.gen_typeobject()
190        return out
191
192    def gen_struct(self):
193        out = """
194// {shortname} structure
195typedef struct{{
196    PyObject_HEAD
197    // pointer to aubio object
198    {longname} *o;
199    // input parameters
200    {input_params_list};
201    // do input vectors
202    {do_inputs_list};
203    // output results
204    {struct_outputs};
205}} Py_{shortname};
206"""
207        # fmat_t* / fvec_t* / cvec_t* inputs -> full fvec_t /.. struct in Py_{shortname}
208        do_inputs_list = "; ".join(get_input_params(self.do_proto)).replace('fvec_t *','fvec_t').replace('fmat_t *', 'fmat_t').replace('cvec_t *', 'cvec_t')
209        return out.format(do_inputs_list = do_inputs_list, **self.__dict__)
210
211    def gen_doc(self):
212        out = """
213// TODO: add documentation
214static char Py_{shortname}_doc[] = \"undefined\";
215"""
216        return out.format(**self.__dict__)
217
218    def gen_new(self):
219        out = """
220// new {shortname}
221static PyObject *
222Py_{shortname}_new (PyTypeObject * pytype, PyObject * args, PyObject * kwds)
223{{
224    Py_{shortname} *self;
225""".format(**self.__dict__)
226        params = self.input_params
227        for p in params:
228            out += """
229    {type} {name} = {defval};""".format(defval = param_init[p['type']], **p)
230        plist = ", ".join(["\"%s\"" % p['name'] for p in params])
231        out += """
232    static char *kwlist[] = {{ {plist}, NULL }};""".format(plist = plist)
233        argchars = "".join([pyargparse_chars[p['type']] for p in params])
234        arglist = ", ".join(["&%s" % p['name'] for p in params])
235        out += """
236    if (!PyArg_ParseTupleAndKeywords (args, kwds, "|{argchars}", kwlist,
237              {arglist})) {{
238        return NULL;
239    }}
240""".format(argchars = argchars, arglist = arglist)
241        out += """
242    self = (Py_{shortname} *) pytype->tp_alloc (pytype, 0);
243    if (self == NULL) {{
244        return NULL;
245    }}
246""".format(**self.__dict__)
247        params = self.input_params
248        for p in params:
249            out += self.check_valid(p)
250        out += """
251    return (PyObject *)self;
252}
253"""
254        return out
255
256    def check_valid(self, p):
257        if p['type'] == 'uint_t':
258            return self.check_valid_uint(p)
259        if p['type'] == 'char_t*':
260            return self.check_valid_char(p)
261        else:
262            print ("ERROR, no idea how to check %s for validity" % p['type'])
263
264    def check_valid_uint(self, p):
265        name = p['name']
266        return """
267    self->{name} = {defval};
268    if ((sint_t){name} > 0) {{
269        self->{name} = {name};
270    }} else if ((sint_t){name} < 0) {{
271        PyErr_SetString (PyExc_ValueError, "can not use negative value for {name}");
272        return NULL;
273    }}
274""".format(defval = aubiodefvalue[name], name = name)
275
276    def check_valid_char(self, p):
277        name = p['name']
278        return """
279    self->{name} = {defval};
280    if ({name} != NULL) {{
281        self->{name} = {name};
282    }}
283""".format(defval = aubiodefvalue[name], name = name)
284
285    def gen_init(self):
286        out = """
287// init {shortname}
288static int
289Py_{shortname}_init (Py_{shortname} * self, PyObject * args, PyObject * kwds)
290{{
291""".format(**self.__dict__)
292        new_name = get_name(self.new_proto)
293        new_params = ", ".join(["self->%s" % s['name'] for s in self.input_params])
294        out += """
295  self->o = {new_name}({new_params});
296""".format(new_name = new_name, new_params = new_params)
297        paramchars = "%s"
298        paramvals = "self->method"
299        out += """
300  // return -1 and set error string on failure
301  if (self->o == NULL) {{
302    //char_t errstr[30 + strlen(self->uri)];
303    //sprintf(errstr, "error creating {shortname} with params {paramchars}", {paramvals});
304    char_t errstr[60];
305    sprintf(errstr, "error creating {shortname} with given params");
306    PyErr_SetString (PyExc_Exception, errstr);
307    return -1;
308  }}
309""".format(paramchars = paramchars, paramvals = paramvals, **self.__dict__)
310        output_create = ""
311        for o in self.outputs:
312            output_create += """
313  self->{name} = {create_fn}({output_size});""".format(name = o['name'], create_fn = newfromtype_fn[o['type']], output_size = objoutsize[self.shortname])
314        out += """
315  // TODO get internal params after actual object creation?
316"""
317        out += """
318  // create outputs{output_create}
319""".format(output_create = output_create)
320        out += """
321  return 0;
322}
323"""
324        return out
325
326    def gen_memberdef(self):
327        out = """
328static PyMemberDef Py_{shortname}_members[] = {{
329""".format(**self.__dict__)
330        for p in get_params_types_names(self.new_proto):
331            tmp = "  {{\"{name}\", {ttype}, offsetof (Py_{shortname}, {name}), READONLY, \"TODO documentation\"}},\n"
332            pytype = member_types[p['type']]
333            out += tmp.format(name = p['name'], ttype = pytype, shortname = self.shortname)
334        out += """  {NULL}, // sentinel
335};
336"""
337        return out
338
339    def gen_del(self):
340        out = """
341// del {shortname}
342static void
343Py_{shortname}_del  (Py_{shortname} * self, PyObject * unused)
344{{""".format(**self.__dict__)
345        for input_param in self.do_inputs:
346            if input_param['type'] == 'fmat_t *':
347                out += """
348    free(self->{0[name]}.data);""".format(input_param)
349        for o in self.outputs:
350            name = o['name']
351            del_out = delfromtype_fn[o['type']]
352            out += """
353    {del_out}(self->{name});""".format(del_out = del_out, name = name)
354        del_fn = get_name(self.del_proto)
355        out += """
356    if (self->o) {{
357        {del_fn}(self->o);
358    }}
359    Py_TYPE(self)->tp_free((PyObject *) self);
360}}
361""".format(del_fn = del_fn)
362        return out
363
364    def gen_do(self):
365        output = self.outputs[0]
366        out = """
367// do {shortname}
368static PyObject*
369Py_{shortname}_do  (Py_{shortname} * self, PyObject * args)
370{{""".format(**self.__dict__)
371        input_params = self.do_inputs
372        output_params = self.do_outputs
373        #print input_params
374        #print output_params
375        for input_param in input_params:
376            out += """
377    PyObject *py_{0};""".format(input_param['name'])
378        refs = ", ".join(["&py_%s" % p['name'] for p in input_params])
379        pyparamtypes = "".join([pyargparse_chars[p['type']] for p in input_params])
380        out += """
381    if (!PyArg_ParseTuple (args, "{pyparamtypes}", {refs})) {{
382        return NULL;
383    }}""".format(refs = refs, pyparamtypes = pyparamtypes, **self.__dict__)
384        for input_param in input_params:
385            out += """
386
387    if (!{pytoaubio}(py_{0[name]}, &(self->{0[name]}))) {{
388        return NULL;
389    }}""".format(input_param, pytoaubio = pytoaubio_fn[input_param['type']])
390        out += """
391
392    // TODO: check input sizes"""
393        for output_param in output_params:
394            out += """
395
396    Py_INCREF(self->{0[name]});
397    if (!{pytoaubio}(self->{0[name]}, &(self->c_{0[name]}))) {{
398        return NULL;
399    }}""".format(output_param, pytoaubio = pytoaubio_fn[output_param['type']])
400        do_fn = get_name(self.do_proto)
401        inputs = ", ".join(['&(self->'+p['name']+')' for p in input_params])
402        c_outputs = ", ".join(["&(self->c_%s)" % p['name'] for p in self.do_outputs])
403        outputs = ", ".join(["self->%s" % p['name'] for p in self.do_outputs])
404        out += """
405
406    {do_fn}(self->o, {inputs}, {c_outputs});
407
408    return {outputs};
409}}
410""".format(
411        do_fn = do_fn,
412        inputs = inputs, outputs = outputs, c_outputs = c_outputs,
413        )
414        return out
415
416    def gen_set(self):
417        out = """
418// {shortname} setters
419""".format(**self.__dict__)
420        for set_param in self.prototypes['set']:
421            params = get_params_types_names(set_param)[1]
422            paramtype = params['type']
423            method_name = get_name(set_param)
424            param = method_name.split('aubio_'+self.shortname+'_set_')[-1]
425            pyparamtype = pyargparse_chars[paramtype]
426            out += """
427static PyObject *
428Pyaubio_{shortname}_set_{param} (Py_{shortname} *self, PyObject *args)
429{{
430  uint_t err = 0;
431  {paramtype} {param};
432
433  if (!PyArg_ParseTuple (args, "{pyparamtype}", &{param})) {{
434    return NULL;
435  }}
436  err = aubio_{shortname}_set_{param} (self->o, {param});
437
438  if (err > 0) {{
439    PyErr_SetString (PyExc_ValueError, "error running aubio_{shortname}_set_{param}");
440    return NULL;
441  }}
442  Py_RETURN_NONE;
443}}
444""".format(param = param, paramtype = paramtype, pyparamtype = pyparamtype, **self.__dict__)
445        return out
446
447    def gen_get(self):
448        out = """
449// {shortname} getters
450""".format(**self.__dict__)
451        for method in self.prototypes['get']:
452            params = get_params_types_names(method)
453            method_name = get_name(method)
454            assert len(params) == 1, \
455                "get method has more than one parameter %s" % params
456            param = method_name.split('aubio_'+self.shortname+'_get_')[-1]
457            paramtype = get_return_type(method)
458            ptypeconv = pyfromtype_fn[paramtype]
459            out += """
460static PyObject *
461Pyaubio_{shortname}_get_{param} (Py_{shortname} *self, PyObject *unused)
462{{
463  {ptype} {param} = aubio_{shortname}_get_{param} (self->o);
464  return (PyObject *){ptypeconv} ({param});
465}}
466""".format(param = param, ptype = paramtype, ptypeconv = ptypeconv,
467        **self.__dict__)
468        return out
469
470    def gen_methodef(self):
471        out = """
472static PyMethodDef Py_{shortname}_methods[] = {{""".format(**self.__dict__)
473        for m in self.prototypes['set']:
474            name = get_name(m)
475            shortname = name.replace('aubio_%s_' % self.shortname, '')
476            out += """
477  {{"{shortname}", (PyCFunction) Py{name},
478    METH_VARARGS, ""}},""".format(name = name, shortname = shortname)
479        for m in self.prototypes['get']:
480            name = get_name(m)
481            shortname = name.replace('aubio_%s_' % self.shortname, '')
482            out += """
483  {{"{shortname}", (PyCFunction) Py{name},
484    METH_NOARGS, ""}},""".format(name = name, shortname = shortname)
485        out += """
486  {NULL} /* sentinel */
487};
488"""
489        return out
490
491    def gen_typeobject(self):
492        return """
493PyTypeObject Py_{shortname}Type = {{
494  //PyObject_HEAD_INIT (NULL)
495  //0,
496  PyVarObject_HEAD_INIT (NULL, 0)
497  "aubio.{shortname}",
498  sizeof (Py_{shortname}),
499  0,
500  (destructor) Py_{shortname}_del,
501  0,
502  0,
503  0,
504  0,
505  0,
506  0,
507  0,
508  0,
509  0,
510  (ternaryfunc)Py_{shortname}_do,
511  0,
512  0,
513  0,
514  0,
515  Py_TPFLAGS_DEFAULT,
516  Py_{shortname}_doc,
517  0,
518  0,
519  0,
520  0,
521  0,
522  0,
523  Py_{shortname}_methods,
524  Py_{shortname}_members,
525  0,
526  0,
527  0,
528  0,
529  0,
530  0,
531  (initproc) Py_{shortname}_init,
532  0,
533  Py_{shortname}_new,
534}};
535""".format(**self.__dict__)
Note: See TracBrowser for help on using the repository browser.