def funcpyx(desc): """Generates a ``*.pyx`` Cython wrapper implementation for exposing a C/C++ function based off of a dictionary description. Parameters ---------- desc : dict Class description dictonary. Returns ------- pyx : str Cython ``*.pyx`` implementation as in-memory string. """ nodocmsg = "no docstring for {0}, please file a bug report!" inst_name = desc['cpppxd_filename'].rsplit('.', 1)[0] import_tups = set() cimport_tups = set(((inst_name,),)) flines = [] funccounts = _count0(desc['signatures']) currcounts = {k: 0 for k in funccounts} mangled_fnames = {} funcitems = sorted(desc['signatures'].items()) for fkey, frtn in funcitems: fname, fargs = fkey[0], fkey[1:] if fname.startswith('_'): continue # skip private if 1 < funccounts[fname]: fname_mangled = "_{0}_{1:0{2}}".format(fname, currcounts[fname], int(math.log(funccounts[fname], 10)+1)).lower() else: fname_mangled = fname currcounts[fname] += 1 mangled_fnames[fkey] = fname_mangled for a in fargs: cython_import_tuples(a[1], import_tups) cython_cimport_tuples(a[1], cimport_tups) cython_import_tuples(frtn, import_tups) cython_cimport_tuples(frtn, cimport_tups) fdoc = desc.get('docstring', nodocmsg.format(fname)) fdoc = _doc_add_sig(fdoc, fname, fargs) flines += _gen_method(fname, fname_mangled, fargs, frtn, fdoc, inst_name=inst_name) if 1 < funccounts[fname] and currcounts[fname] == funccounts[fname]: # write dispatcher nm = {k: v for k, v in mangled_fnames.iteritems() if k[0] == fname} flines += _gen_dispatcher(fname, nm, doc=fdoc) flines.append(desc.get('extra', {}).get('pyx', '')) pyx = '\n'.join(flines) if 'pyx_filename' not in desc: desc['pyx_filename'] = '{0}.pyx'.format(desc['name'].lower()) return import_tups, cimport_tups, pyx
def classpyx(desc, classes=None): """Generates a ``*.pyx`` Cython wrapper implementation for exposing a C/C++ class based off of a dictionary description. The environment is a dictionary of all class names known to their descriptions. Parameters ---------- desc : dict Class description dictonary. classes : dict, optional Dictionary which maps all class names that are required to their own descriptions. This is required for resolving class heirarchy dependencies. Returns ------- pyx : str Cython ``*.pyx`` implementation file as in-memory string. """ if classes is None: classes = {desc['name']: desc} nodocmsg = "no docstring for {0}, please file a bug report!" pars = ', '.join([cython_cytype(p) for p in desc['parents'] or ()]) d = {'parents': pars if 0 == len(pars) else '('+pars+')'} copy_from_desc = ['name', 'namespace', 'header_filename'] for key in copy_from_desc: d[key] = desc[key] class_doc = desc.get('docstrings', {}).get('class', nodocmsg.format(desc['name'])) d['class_docstring'] = indent('\"\"\"{0}\"\"\"'.format(class_doc)) class_ctype = cython_ctype(desc['name']) inst_name = "(<{0} *> self._inst)".format(class_ctype) import_tups = set() cimport_tups = set() for parent in desc['parents'] or (): cython_import_tuples(parent, import_tups) cython_cimport_tuples(parent, cimport_tups) alines = [] cached_names = [] attritems = sorted(desc['attrs'].items()) for aname, atype in attritems: if aname.startswith('_'): continue # skip private adoc = desc.get('docstrings', {}).get('attrs', {})\ .get(aname, nodocmsg.format(aname)) alines += _gen_property(aname, atype, adoc, cached_names=cached_names, inst_name=inst_name) cython_import_tuples(atype, import_tups) cython_cimport_tuples(atype, cimport_tups) d['attrs_block'] = indent(alines) pd = ["{0} = None".format(n) for n in cached_names] d['property_defaults'] = indent(indent(pd, join=False)) mlines = [] clines = [] methcounts = _count0(desc['methods']) currcounts = {k: 0 for k in methcounts} mangled_mnames = {} methitems = sorted(desc['methods'].items()) for mkey, mrtn in methitems: mname, margs = mkey[0], mkey[1:] if mname.startswith('_'): continue # skip private if 1 < methcounts[mname]: mname_mangled = "_{0}_{1}_{2:0{3}}".format(desc['name'], mname, currcounts[mname], int(math.log(methcounts[mname], 10)+1)).lower() else: mname_mangled = mname currcounts[mname] += 1 mangled_mnames[mkey] = mname_mangled for a in margs: cython_import_tuples(a[1], import_tups) cython_cimport_tuples(a[1], cimport_tups) minst_name, mcname = _method_instance_names(desc, classes, mkey, mrtn) if mcname != desc['name']: cython_import_tuples(mcname, import_tups) cython_cimport_tuples(mcname, cimport_tups) if mrtn is None: # this must be a constructor if mname not in (desc['name'], '__init__'): continue # skip destuctors if 1 == methcounts[mname]: mname_mangled = '__init__' mangled_mnames[mkey] = mname_mangled mdoc = desc.get('docstrings', {}).get('methods', {}).get(mname, '') mdoc = _doc_add_sig(mdoc, mname, margs) clines += _gen_constructor(mname, mname_mangled, desc['name'], margs, doc=mdoc, cpppxd_filename=desc['cpppxd_filename'], inst_name=minst_name) if 1 < methcounts[mname] and currcounts[mname] == methcounts[mname]: # write dispatcher nm = {k: v for k, v in mangled_mnames.iteritems() if k[0] == mname} clines += _gen_dispatcher('__init__', nm, doc=mdoc, hasrtn=False) else: # this is a normal method cython_import_tuples(mrtn, import_tups) cython_cimport_tuples(mrtn, cimport_tups) mdoc = desc.get('docstrings', {}).get('methods', {})\ .get(mname, nodocmsg.format(mname)) mdoc = _doc_add_sig(mdoc, mname, margs) mlines += _gen_method(mname, mname_mangled, margs, mrtn, mdoc, inst_name=minst_name) if 1 < methcounts[mname] and currcounts[mname] == methcounts[mname]: # write dispatcher nm = {k: v for k, v in mangled_mnames.iteritems() if k[0] == mname} mlines += _gen_dispatcher(mname, nm, doc=mdoc) if desc['parents'] is None: clines += ["def __dealloc__(self):"] clines += indent("if self._free_inst:", join=False) clines += indent(indent("free(self._inst)", join=False), join=False) cimport_tups.add(('libc.stdlib', 'free')) d['methods_block'] = indent(mlines) d['constructor_block'] = indent(clines) d['extra'] = desc.get('extra', {}).get('pyx', '') pyx = _pyx_class_template.format(**d) if 'pyx_filename' not in desc: desc['pyx_filename'] = '{0}.pyx'.format(d['name'].lower()) return import_tups, cimport_tups, pyx