1. windwiny
  2. wxPython


wxPython / docs / bin / simplify.py

# Like simplify.xsl but using Python so a few non-standard conversions can
# also be done.  (Currently it is still about the same as simplify.xsl...)

import sys
import os
import libxml2


classMap = {
    'wxString'   : 'String',
    'void'       : '',

def getModuleNames():
    Get the list of extension modules from setup.py
    import setup
    names = [e.name[1:] for e in setup.wxpExtensions]
    return names

def getAttr(node, name):
    Get a value by name from the <attribute> elements in the SWIG XML output
    path = "./attributelist/attribute[@name='%s']/@value" % name
    n = node.xpathEval2(path)
    if len(n):
        return n[0].content
        return None

def fixType(typeStr):
    Fixup type string, dropping the swig pointer and other flags
    pos = typeStr.rfind('.')
    if pos != -1:
        typeStr = typeStr[pos+1:]
    return classMap.get(typeStr, typeStr)

def processModule(newDocNode, modulename):
    Start processing a new XML file, create a module element and then
    find the include elements
    filename = os.path.join(SRC, "%s_swig.xml" % modulename)
    print filename

    doc = libxml2.parseFile(filename)
    topNode = doc.getRootElement()

    # make a module element
    name = getAttr(topNode, "module")
    ##assert name == modulename # sanity check    

    moduleNode = libxml2.newNode("module")
    moduleNode.setProp("name", name)    

    node = topNode.children
    while node is not None:
        if node.name == "include":
            processInclude(moduleNode, node)
        node = node.next


def processInclude(moduleNode, includeNode):
    Almost everything we are interested in is inside an <include>,
    which may also be nested.

    # check first for imports
    for node in includeNode.xpathEval2("import"):
            modNode = node.xpathEval2("module")[0]
            name = getAttr(modNode, "name")
            impNode = libxml2.newNode("import")
            impNode.setProp("name", name)
        except IndexError:
    # then look through the child nodes for other things we need
    node = includeNode.children
    while node is not None:
        if node.name == "insert":
            processInsert(moduleNode, node)

        elif node.name == "class":
            processClass(moduleNode, node)

        elif node.name == "cdecl" and getAttr(node, "view") == "globalfunctionHandler":
            func = libxml2.newNode("method")
            func.setProp("name",    getAttr(node, "sym_name"))
            func.setProp("oldname", getAttr(node, "name"))
            func.setProp("type",    fixType(getAttr(node, "type")))
            doCheckOverloaded(func, node)
            doDocStrings(func, node)
            doParamList(func, node)
        elif node.name == "include":
            processInclude(moduleNode, node)

        node = node.next

def processInsert(parentNode, insertNode):
    Check for pythoncode
    if getAttr(insertNode, "section") == "python":
        code = getAttr(insertNode, "code")
        node = libxml2.newNode("pythoncode")

def processClass(parentNode, classNode):
    Handle classes, constructors, methods, etc.
    # make class element
    klass = libxml2.newNode("class")
    name = getAttr(classNode, "sym_name")
    oldname = getAttr(classNode, "name")
    classMap[oldname] = name
    klass.setProp("name",    name)
    klass.setProp("oldname", oldname)
    klass.setProp("module",  getAttr(classNode, "module"))
    doDocStrings(klass, classNode)

    # check for baseclass(es)
    for node in classNode.xpathEval2("attributelist/baselist/base"):
        baseclass = libxml2.newNode("baseclass")
        basename = node.prop("name")
        baseclass.setProp("name", classMap.get(basename, basename))

    # check for constructors/destructors
    for type in ["constructor", "destructor"]:
        for node in classNode.xpathEval2("%s | extend/%s" % (type, type)):
            func = libxml2.newNode(type)
            func.setProp("name", getAttr(node, "sym_name"))
            if parentNode.name != "destructor":
                doCheckOverloaded(func, node)
            doDocStrings(func, node)
            doParamList(func, node)

    # check for cdecl's.  In class scope we are interested in methods,
    # static methods, or properties
    for node in classNode.xpathEval2("cdecl | extend/cdecl"):
        view = getAttr(node, "view")
        if view == "memberfunctionHandler":
            func = libxml2.newNode("method")
            func.setProp("name", getAttr(node, "sym_name"))
            func.setProp("type", fixType(getAttr(node, "type")))
            doCheckOverloaded(func, node)
            doDocStrings(func, node)
            doParamList(func, node)
        elif view == "staticmemberfunctionHandler":
            func = libxml2.newNode("staticmethod")
            func.setProp("name", getAttr(node, "sym_name"))
            func.setProp("type", fixType(getAttr(node, "type")))
            doCheckOverloaded(func, node)
            doDocStrings(func, node)
            doParamList(func, node)
        elif view == "variableHandler":
            prop = libxml2.newNode("property")
            prop.setProp("name", getAttr(node, "sym_name"))
            prop.setProp("type", fixType(getAttr(node, "type")))
            if getAttr(node, "feature_immutable"):
                prop.setProp("readonly", "yes")
                prop.setProp("readonly", "no")
            doDocStrings(prop, node)

def doParamList(parentNode, srcNode):
    Convert the parameter list
    params = srcNode.xpathEval2("attributelist/parmlist/parm")
    if params:
        plist = libxml2.newNode("paramlist")
        for p in params:
            pnode = libxml2.newNode("param")
            pnode.setProp("name", getAttr(p, "name"))
            pnode.setProp("type", fixType(getAttr(p, "type")))
            pnode.setProp("default", getAttr(p, "value"))

def doCheckOverloaded(parentNode, srcNode):
    Set an attribute indicating if the srcNode is tagged as being overloaded
    if srcNode.xpathEval2("./attributelist/attribute[@name='sym_overloaded']"):
        parentNode.setProp("overloaded", "yes")
        parentNode.setProp("overloaded", "no")

def doDocStrings(parentNode, srcNode):
    Check for the various possible docstring attributes, and attach
    coresponding child nodes if found.
    def makeDocElement(name, content):
        node = libxml2.newNode(name)
        return node
    autodoc = getAttr(srcNode, "python_autodoc")
    docstr  = getAttr(srcNode, "feature_docstring")
    if autodoc:
        parentNode.addChild(makeDocElement("autodoc", autodoc))
    if docstr:
        parentNode.addChild(makeDocElement("docstring", docstr))

def main():
    if not os.path.exists(SRC):
        print "Unable to find %s, please run this script from the root wxPython directory." % SRC

    newDoc = libxml2.newDoc("1.0")
    newTopNode = libxml2.newNode("wxPython-metadata")
    for m in getModuleNames():
        processModule(newTopNode, m)

    newDoc.saveFormatFile(DEST, True)
    print "Wrote simplified metadata to", DEST


if __name__ == "__main__":