In This Package:

xmlCollect.py

Go to the documentation of this file.

#!/usr/bin/env python
#
# Collect XML indexes for multiple runs into a single file
#
# Usage:
#   % xmlCollect [-o output] indexFile [collectedIndexes]

INDEX_DTD = """
 <!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> 
 
 ]>
"""

COPY = False

PATH_TO_INDEX = 'diagnostics/xml/'

XML_INDEX_INDEX = 0;
XML_COLLECTION_INDEX = 1;

DIAGNOSTIC_INDEX_TAG = 'diagnostic_index'
RUN_TAG = 'run'
RUN_NUMBER_TAG = 'runnumber'
RUN_INDEX_TAG = 'runindex'

ID_ATTR = 'id'

def createRunFromValues(document, runIdValue, runNumberValue, runIndexValue):
    """Create a run element from the provided values"""
    runNode = document.createElement(RUN_TAG)
    runId = document.createAttribute(ID_ATTR)
    runId.value = runIdValue
    runNode.setAttributeNode(runId)
    runNumberNode = document.createElement(RUN_NUMBER_TAG)
    runNumber = document.createTextNode(runNumberValue)
    runNode.appendChild(document.createTextNode('\n  '))
    runNumberNode.appendChild(runNumber)
    runNode.appendChild(runNumberNode)
    runIndexNode = document.createElement(RUN_INDEX_TAG)
    path = PATH_TO_INDEX + runIndexValue
    runIndex = document.createTextNode(path)
    runIndexNode.appendChild(runIndex)
    runNode.appendChild(document.createTextNode('\n  '))
    runNode.appendChild(runIndexNode)
    runNode.appendChild(document.createTextNode('\n '))
    return runNode


def createRunFromElement(document,
                         node,
                         runIndexValue):
    """Create a run element from the provided run Element"""
    number = node.getElementsByTagName(RUN_NUMBER_TAG).item(0)
    return createRunFromValues(document,
                               node.getAttribute(ID_ATTR),
                               number.firstChild.data,
                               runIndexValue)


def collectIndexes(existingContent,
                   freshContent,
                   xmlIndex):
    root = existingContent.getElementsByTagName(DIAGNOSTIC_INDEX_TAG).item(0)
    entries = {}
    existing = existingContent.getElementsByTagName(RUN_TAG)
    index = 0
    for node in existing:
        for number in node.getElementsByTagName(RUN_NUMBER_TAG):
            entries[number.firstChild.data] = index
        index += 1

    for node in freshContent.getElementsByTagName(RUN_TAG):
        number = node.getElementsByTagName(RUN_NUMBER_TAG).item(0)
        key = number.firstChild.data
        if key in entries:
            print 'Updating entry for run ' + key
            if COPY:
                runNode = node
            else:
                runNode = createRunFromElement(existingContent,
                                               node,
                                               os.path.basename(xmlIndex))
            root.replaceChild(runNode,
                              existing.item(entries[key]))
        else:
            pass
            idValue = key
            while 7 > len(idValue):
                idValue = '0' + idValue
            runNode = createRunFromValues(existingContent,
                                          'run_' + idValue,
                                          key,
                                          os.path.basename(xmlIndex))
            root.appendChild(existingContent.createTextNode(' '))
            root.appendChild(runNode)
            root.appendChild(existingContent.createTextNode('\n'))
    return existingContent


if __name__ == "__main__":

    import os
    import sys
    from optparse import OptionParser, OptionGroup, IndentedHelpFormatter
    from xml.dom.minidom import parse, parseString

    parser = OptionParser(usage="xmlCollect xmlIndex xmlCollection",
                          version="%prog 1.0")

    parser.add_option('-o',
                      '--output',
                      dest='OUTPUT',
                      help='file into which to write the output',
                      default=None)

    parser.add_option('-p',
                      '--path-to-index',
                      dest='PATH_TO_INDEX',
                      help='relative path from collection to index',
                      default=None)
    import sys
    (options, args) = parser.parse_args()

    if None != options.PATH_TO_INDEX:
        PATH_TO_INDEX = options.PATH_TO_INDEX+'/'

    if XML_INDEX_INDEX >= len(args):
        sys.exit(1)
    else:
        xmlIndex = args[XML_INDEX_INDEX]
        print "Collecting runs from " + xmlIndex
        fresh = parse(xmlIndex)
        
    if XML_COLLECTION_INDEX >= len(args):
        empty = '<?xml version="1.0" ?>\n' + INDEX_DTD + "<diagnostic_index/>"
        existing = parseString(empty)
    else:
        input = args[XML_COLLECTION_INDEX]
        print "Updating " + input
        existing = parse(input)
    
    if None != options.OUTPUT:
        xmlFile = open(options.OUTPUT,
                       'w')
        if not xmlFile:
            print "Failed to open XML index output file:", outFile
            sys.exit(1)
    else:
        xmlFile = sys.stdout

    collection = collectIndexes(existing,
                                fresh,
                                xmlIndex)
    collection.writexml(xmlFile)

    if sys.stdout != xmlFile:
        xmlFile.close();

---