In This Package:

xmlIndex.py

Go to the documentation of this file.

#!/usr/bin/env python
#
# Generate an index of root file contents
#
# Usage:
#   % xmlIndex.py histograms.root index.xml

indexDtd = """
 <!DOCTYPE diagnostic_index [ 

 <!ELEMENT diagnostic_index (run*)>
 <!ELEMENT run (runnumber,runindex?,detector*,figure*)>
 <!ELEMENT runnumber (#PCDATA)>
 <!ELEMENT runindex (#PCDATA)>
 <!ELEMENT detector (detname, figure*, channel*)>
 <!ELEMENT detname (#PCDATA)>
 <!ELEMENT channel (channelname, figure*)>
 <!ELEMENT channelname (#PCDATA)>
 <!ELEMENT figure (path,figname,rootPath,figtitle)>
 <!ELEMENT path (#PCDATA)>
 <!ELEMENT figname (#PCDATA)>
 <!ELEMENT rootPath (#PCDATA)>
 <!ELEMENT figtitle (#PCDATA)>

 <!ATTLIST run id ID #REQUIRED> 
 <!ATTLIST detector id ID #REQUIRED> 
 <!ATTLIST channel id ID #REQUIRED>
 <!ATTLIST figure id ID #REQUIRED> 
 
 ]>
"""


def writeXml(outFile, currentIndex):
    """Write current index to output file"""
    xmlfile = open(outFile,'w')
    if not xmlfile:
        print "Failed to open XML index output file: ",outFile
        return
    xmlfile.write( '<?xml version="1.0" ?>\n' )
    global indexDtd
    xmlfile.write( indexDtd )
    prettyXml = currentIndex.toprettyxml(" ")
    lines = prettyXml.split("\n")
    prettierLines = []
    closeText=False
    for line in lines:
        stLine = line.strip()
        if len(stLine)==0: continue
        if closeText and stLine[0:2]=='</':
            prettierLines[-1] += stLine
            closeText=False
            continue
        if stLine[0]=='<':
            prettierLines.append(line)
            continue
        # Found text line, add to previous block
        prettierLines[-1] += stLine
        closeText=True
    xmlfile.write( '\n'.join(prettierLines) )
    xmlfile.close()
    return


class XmlIndexGenerator:
    """XML Index Generator Class"""
    def __init__(self, filename, rootPath, fileRoot, xmlIndex, pathReplace):
        "Constructor"
        self.filename = filename
        self.rootPath = rootPath
        self.fileRoot = fileRoot
        self.xmlIndex = xmlIndex
        self.pathReplace = pathReplace
        self.file = None
        self.format = "png"
        self.xml = None
        self.rootElem = None
        return

    def process(self):
        """Generate XML"""
        if not self.openFile():
            return
        self.xmlOpen()
        self.processPath("diagnostics",None)
        self.xmlClose()
        return
        
    def openFile(self):
        "Open root file"
        import ROOT
        rootFile = ROOT.TFile(self.filename)
        if not rootFile:
            print "Failed to open root file:",filename
            return False
        self.file = rootFile
        return True

    def processPath(self, itemPath, parentElem):
        """Process a path in the current root file"""
        #print "Processing:",itemPath
        filePath = self.fileRoot + "/" + itemPath
        content = self.file.Get(filePath);
        if not content:
            print "Failed to get item at: ", itemPath
            return
        if (content.IsA().InheritsFrom("TH1")
            or content.IsA().InheritsFrom("TGraph")):
            # Found a figure.  Index it.
            self.indexFigure(content, itemPath, parentElem)
        elif content.IsA().InheritsFrom("TDirectory"):
            # Found a directory.  Index it
            newElem = None
            newElem = self.tryDiagnostics(itemPath, parentElem)
            if not newElem:
                newElem = self.tryRun(itemPath, parentElem)
            if not newElem:
                newElem = self.tryDetector(itemPath, parentElem)
            if not newElem:
                newElem = self.tryChannel(itemPath, parentElem)
            if not newElem:
                print "Will not index path: ", itemPath
                return
            keylist = content.GetListOfKeys()
            for key in keylist:
                dirItem = key.ReadObj()
                dirItemPath = None
                if len(itemPath)>0:
                    dirItemPath = itemPath+"/"+dirItem.GetName()
                else:
                    dirItemPath = dirItem.GetName()
                self.processPath(dirItemPath, newElem)
        else:
            # Won't handle this object
            print "Not handing %s of type %s" % (filepath,content.ClassName())
        return

    def xmlOpen(self):
        """Create XML index header"""
        import xml.dom.minidom
        self.xml = xml.dom.minidom.Document()
        return

    def xmlClose(self):
        """Close XML index, write to output file"""
        writeXml(self.xmlIndex, self.rootElem)
        return

    def indexFigure(self, item, itemPath, parentElem):
        """Check path and add to XML index"""
        if parentElem.localName in ['run','detector','channel']: 
            # Add figure to parent
            figPath = itemPath + '.' + self.format
            # Replace figure path if needed
            if self.pathReplace:
                for key in self.pathReplace.keys():
                    figPath = figPath.replace(key,self.pathReplace[key])
            parentId = parentElem.attributes['id'].value
            figElem = self.createXmlNode('figure',
                                         {'figname':item.GetName(),
                                          'path':figPath,
                                          'figtitle':item.GetTitle(),
                                          'rootPath':self.rootPath},
                                         {'id':parentId+'_'+item.GetName()})
            parentElem.appendChild(figElem)
        return figElem

    def createXmlNode(self, name, children=None, attributes=None):
        newElem = self.xml.createElement(name)
        if children:
            for child in children.keys():
                childElem = self.xml.createElement(child)
                childContent = self.xml.createTextNode(children[child])
                childElem.appendChild(childContent)
                newElem.appendChild(childElem)
        if attributes:
            for attrName in attributes.keys():
                newElem.setAttribute(attrName, attributes[attrName])
        return newElem

    def tryDiagnostics(self, itemPath, parentElem):
        """Check if path is in 'diagnostics' format"""
        if parentElem: return None
        pathParts = itemPath.split('/')
        if len(pathParts)!=1: return None
        if itemPath != 'diagnostics': return None
        self.rootElem = self.createXmlNode('diagnostic_index')
        return self.rootElem

    def tryRun(self, itemPath, parentElem):
        """Check if path is in 'run' format"""
        if parentElem.localName != 'diagnostic_index':
            return None
        pathParts = itemPath.split('/')
        if len(pathParts)!=2: return None
        runPart = pathParts[-1]
        if len(runPart)!=11: return None
        if not runPart.startswith("run_"): return None
        if not runPart[4:].isdigit(): return None
        runnumber = int(runPart[4:])
        runId = runPart
        if runnumber == 0:
            print "FIXME: sim data has runnumber == 0"
            runpathfix = self.pathReplace.keys()[0]
            runnumber = int(runpathfix[-7:])
            self.pathReplace = {runPart : self.pathReplace[runpathfix]}
            print "FIXME: replacing with runnumber ",runnumber
            runId = runpathfix
        runElem = self.createXmlNode('run',{'runnumber':str(runnumber)},
                                     {'id':runId})
        parentElem.appendChild(runElem)
        return runElem

    def tryDetector(self, itemPath, parentElem):
        """Check if path is in 'detector' format"""
        if parentElem.localName != 'run':
            return None
        pathParts = itemPath.split('/')
        if len(pathParts)!=3: return None
        detPart = pathParts[-1]
        if not detPart.startswith("detector_"): return None
        detectorId = parentElem.attributes.get('id').nodeValue + '_' + detPart
        detectorName = detPart[9:]
        detElem = self.createXmlNode('detector',{'detname':detectorName},
                                     {'id':detectorId})
        parentElem.appendChild(detElem)
        return detElem

    def tryChannel(self, itemPath, parentElem):
        """Check if path is in 'channel' format"""
        if parentElem.localName != 'detector':
            return None
        pathParts = itemPath.split('/')
        if len(pathParts)!=4: return None
        chanPart = pathParts[-1]
        if not chanPart.startswith("channel_"): return None
        channelId = parentElem.attributes.get('id').nodeValue + '_' + chanPart
        channelName = chanPart[8:]
        channelElem = self.createXmlNode('channel',
                                         {'channelname':channelName},
                                         {'id':channelId})
        parentElem.appendChild(channelElem)
        return channelElem

class XmlIndexUpdater:
    """XML Index Updater class"""
    def __init__(self, oldIndex, indexUpdate, newIndex):
        "Constructor"
        self.oldIndex = oldIndex
        self.indexUpdate = indexUpdate
        self.newIndex = newIndex
        return

    def process(self):
        """Update an existing index with entries from new index"""
        import xml.dom.minidom
        currentXml = xml.dom.minidom.parse(self.oldIndex)
        xmlUpdate = xml.dom.minidom.parse(self.indexUpdate)
        self.removeWhitespace(currentXml)
        self.removeWhitespace(xmlUpdate)
        currentIndex = self.getIndex(currentXml)
        indexUpdate = self.getIndex(xmlUpdate)
        self.updateXml(currentIndex,indexUpdate)
        writeXml( self.newIndex, currentIndex )
        return True

    def getIndex(self, xmlDoc):
        """Get the diagnostics index from this XML document"""
        diagIndex = None
        for child in xmlDoc.childNodes:
            if (child.nodeType==child.ELEMENT_NODE
                and child.localName == "diagnostic_index"):
                diagIndex = child
                break
        if not diagIndex:
            print "XML document has no diagnostic index"
        return diagIndex

    def updateXml(self, currentElement, updateElement):
        """Recursively update XML elements"""
        mergeChildren = {}
        simpleElements = {}
        firstIdElement = None
        for child in list(currentElement.childNodes):
            #print "processing child: ",child.toxml()
            if (child.nodeType==child.ELEMENT_NODE
                and child.hasAttributes()
                and child.hasAttribute('id')):
                # Maintain attributes with IDs, will be updated
                if not firstIdElement == None: firstIdElement = child
                childId = child.attributes['id'].value
                mergeChildren[childId] = child
            else:
                simpleElements[child.localName]=child
        for child in list(updateElement.childNodes):
            if (child.nodeType==child.ELEMENT_NODE
                and child.hasAttribute('id')):
                childId = child.attributes['id'].value
                if mergeChildren.has_key(childId):
                    # Merge elements with same IDs
                    self.updateXml(mergeChildren[childId], child)
                else:
                    # Add element with new ID
                    # print "Adding new element: ",childId
                    currentElement.appendChild(child)
            else:
                if(simpleElements.has_key(child.localName)):
                    # Replace this simple node
                    replaceChild = simpleElements[child.localName]
                    # print "Replacing simple element: ",child.localName
                    currentElement.replaceChild(child, replaceChild)
                    simpleElements[child.localName] = child
                else:
                    # Add new simple node
                    # print "Adding new simple element: ",child.localName
                    currentElement.insertBefore(child, firstIdElement)
        return

    def removeWhitespace(self, xmlElement):
        """Recursively remove excess whitespace from 'pretty' xml"""
        for child in list(xmlElement.childNodes):
            if child.nodeType==child.TEXT_NODE:
                cleanText = child.data.strip()
                if cleanText=='':
                    xmlElement.removeChild(child)
                else:
                    child.data = cleanText
            else:
                self.removeWhitespace(child)
        return

if __name__ == "__main__":

    fileRoot = "stats"
    xmlIndex = "index.xml"
    filename = None
    oldIndex = None
    indexUpdate = None
    rootPath = ""
    pathReplace = None
    import sys, getopt
    opts, args = getopt.getopt(sys.argv[1:],"f:o:p:r:i:u:")
    for opt, arg in opts:
        if opt == "-f":
            filename = arg
        elif opt == "-o":
            xmlIndex = arg
        elif opt == "-p":
            rootPath = arg
        elif opt == "-r":
            items = arg.split(',')
            if len(items)==2:
                if pathReplace==None:
                    pathReplace={}
                pathReplace[items[0].strip()] = items[1].strip()
        elif opt == "-i":
            oldIndex = arg
        elif opt == "-u":
            indexUpdate = arg
    if filename!=None and oldIndex==None and indexUpdate==None:
        # Generate new index
        print "Filename:  ",filename
        print "Root File Local Path:  ",rootPath
        print "XML Index: ",xmlIndex
        if pathReplace:
            print "Run Path Substitute: ",pathReplace
        xmlGen = XmlIndexGenerator(filename, rootPath, fileRoot, xmlIndex,
                                   pathReplace)
        xmlGen.process()
        print "Done with index generation"
    elif filename==None and oldIndex!=None and indexUpdate!=None:
        print "New XML Index: ",xmlIndex
        print "Previous XML Index: ",oldIndex
        print "Update XML fragment: ",indexUpdate
        xmlUpd = XmlIndexUpdater(oldIndex, indexUpdate, xmlIndex)
        xmlUpd.process()
        print "Done with index updating"
    else:
        print """ Usage:
        Generate a new index:
        % xmlIndex.py -f run001234.root -o run001234.xml -p ./root/run001245.root
          Options:
            -f: input root filename [REQUIRED]
            -o: output XML index filename
            -p: disk path of root file relative to main index
            -r: replace figure paths with substitute strings '-r old,new'

        Update an existing index:
        % xmlIndex.py -o newIndex.xml -i input.xml -u update.xml
          Options:
            -i: input XML filename [REQUIRED]
            -u: update XML filename [REQUIRED]
            -o: output XML index filename [DEFAULT: index.xml]
        """

    
    

---