1 | aubiodefvalue = { |
---|
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 | |
---|
24 | member_types = { |
---|
25 | 'name': 'type', |
---|
26 | 'char_t*': 'T_STRING', |
---|
27 | 'uint_t': 'T_INT', |
---|
28 | 'smpl_t': 'AUBIO_NPY_SMPL', |
---|
29 | } |
---|
30 | |
---|
31 | pyfromtype_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 | |
---|
38 | pytoaubio_fn = { |
---|
39 | 'fvec_t*': 'PyAubio_ArrayToCFvec', |
---|
40 | 'cvec_t*': 'PyAubio_PyCvecToCCvec', |
---|
41 | #'fmat_t*': 'PyAubio_ArrayToCFmat', |
---|
42 | } |
---|
43 | |
---|
44 | pyfromaubio_fn = { |
---|
45 | 'fvec_t*': 'PyAubio_CFvecToArray', |
---|
46 | 'cvec_t*': 'PyAubio_CCvecToArray', |
---|
47 | 'fmat_t*': 'PyAubio_CFmatToArray', |
---|
48 | } |
---|
49 | |
---|
50 | newfromtype_fn = { |
---|
51 | 'fvec_t*': 'new_py_fvec', |
---|
52 | 'fmat_t*': 'new_py_fmat', |
---|
53 | 'cvec_t*': 'new_py_cvec', |
---|
54 | } |
---|
55 | |
---|
56 | delfromtype_fn = { |
---|
57 | 'fvec_t*': 'Py_DECREF', |
---|
58 | 'fmat_t*': 'Py_DECREF', |
---|
59 | 'cvec_t*': 'Py_DECREF', |
---|
60 | } |
---|
61 | |
---|
62 | param_init = { |
---|
63 | 'char_t*': 'NULL', |
---|
64 | 'uint_t': '0', |
---|
65 | 'sint_t': 0, |
---|
66 | 'smpl_t': 0., |
---|
67 | 'lsmp_t': 0., |
---|
68 | } |
---|
69 | |
---|
70 | pyargparse_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 | |
---|
80 | objoutsize = { |
---|
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 | |
---|
92 | def 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 | |
---|
98 | def 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 | |
---|
105 | def 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 | |
---|
125 | def 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 | |
---|
136 | def 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 | |
---|
140 | def get_output_params(proto): |
---|
141 | a = get_params(proto) |
---|
142 | return [i for i in a if not i.startswith('const ')][1:] |
---|
143 | |
---|
144 | def 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 | |
---|
154 | class 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 |
---|
195 | typedef 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 |
---|
214 | static char Py_{shortname}_doc[] = \"undefined\"; |
---|
215 | """ |
---|
216 | return out.format(**self.__dict__) |
---|
217 | |
---|
218 | def gen_new(self): |
---|
219 | out = """ |
---|
220 | // new {shortname} |
---|
221 | static PyObject * |
---|
222 | Py_{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} |
---|
288 | static int |
---|
289 | Py_{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 = """ |
---|
328 | static 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} |
---|
342 | static void |
---|
343 | Py_{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} |
---|
368 | static PyObject* |
---|
369 | Py_{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'], input_param['type']) |
---|
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 += """ |
---|
427 | static PyObject * |
---|
428 | Pyaubio_{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 += """ |
---|
460 | static PyObject * |
---|
461 | Pyaubio_{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 = """ |
---|
472 | static 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 """ |
---|
493 | PyTypeObject 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__) |
---|