xmlutil.py

General Hidden Markov Model Library 一个通用的隐马尔科夫模型的C代码库

#!/usr/bin/env python
################################################################################
#
#       This file is part of the General Hidden Markov Model Library,
#       GHMM version 0.8_beta1, see http://ghmm.org
#
#       file:    xmlutil.py
#       authors: Wasinee Rungsarityotin, Janne Grunau
#
#       Copyright (C) 1998-2004 Alexander Schliep
#       Copyright (C) 1998-2001 ZAIK/ZPR, Universitaet zu Koeln
#       Copyright (C) 2002-2004 Max-Planck-Institut fuer Molekulare Genetik,
#                               Berlin
#
#       Contact: [e-mail]
#
#       This library is free software; you can redistribute it and/or
#       modify it under the terms of the GNU Library General Public
#       License as published by the Free Software Foundation; either
#       version 2 of the License, or (at your option) any later version.
#
#       This library is distributed in the hope that it will be useful,
#       but WITHOUT ANY WARRANTY; without even the implied warranty of
#       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
#       Library General Public License for more details.
#
#       You should have received a copy of the GNU Library General Public
#       License along with this library; if not, write to the Free
#       Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
#
################################################################################


from DataStructures import Point2D,EdgeWeight
from Graph import Graph, SubGraph

from xml.dom.minidom import *
import EditObjectAttributesDialog
from EditObjectAttributesDialog import ValidatingString, ValidatingInt, ValidatingFloat, PopupableInt, Probability, DefaultedInt, DefaultedString

import string
import types
import copy

import sys 

import logging
log = logging.getLogger("xmlutil.py")

def typed_assign(var, val):
    result = type(var)(val)
    result.__dict__ = var.__dict__
    #result.__dict__ = copy.copy(var.__dict__)
    return result

def listFromCSV(s, type):
    return map(type,string.split(s,','))

def csvFromList(list, perRow = None):
    if perRow == None:
        return string.join(map(str,list), ', ')
    else:
        result = ""
        for start in xrange(0, len(list), perRow):
            result += string.join(map(str,list[start:start+perRow]), ', ') + ',\n'
        return result[0:len(result)-2]

def writeContents(XMLDoc, XMLNode, data):
    contents = XMLDoc.createTextNode("%s" % data)
    XMLNode.appendChild(contents)

def writeData(XMLDoc, XMLNode, dataKey, dataValue):
    data = XMLDoc.createElement("data")
    data.setAttribute('key', "%s" % dataKey)
    contents = XMLDoc.createTextNode("%s" % dataValue)
    data.appendChild(contents)
    XMLNode.appendChild(data)

def writeXMLData(XMLDoc, XMLNode, dataKey, XMLData):
    data = XMLDoc.createElement("data")
    data.setAttribute('key', "%s" % dataKey)
    data.appendChild(XMLData)
    XMLNode.appendChild(data)

def writeXMLTextNode(XMLDoc, XMLNode, keyName, XMLData):
    data = XMLDoc.createElement(keyName)
    contents = XMLDoc.createTextNode("%s" % XMLData)
    data.appendChild(contents)
    XMLNode.appendChild(data)

class NamedDistributions:
    def __init__(self, itsHMM):
        self.initialize()
        self.itsHMM = itsHMM
        self.code2name = {-1:'None'}
        self.name2code = {'None':-1}
        self.maxCode = 0

    def initialize(self):
        self.dist = {}
        self.order = {}
       
    def addDistribution(self, name, order, p): 
        self.dist[name] = p
        self.order[name] = order
        self.code2name[self.maxCode] = name
        self.name2code[name] = self.maxCode
        self.maxCode += 1
        # print self.dist
        
    def deleteDistribution(self, name):
        del self.dist[name]
        del self.order[name]
        del self.code2name[self.name2code[name]]
        del self.name2code[name]
   
    def fromDOM(self, XMLNode):
        self.initialize()
        datas = XMLNode.getElementsByTagName("hmm:background")
        for data in datas:
            dataKey = data.attributes['key'].nodeValue
            dataOrder = int(data.attributes['order'].nodeValue)
            dataValue = ""
            for child in data.childNodes:
                dataValue += child.nodeValue
            p = listFromCSV(dataValue, types.FloatType)
            self.addDistribution(dataKey, dataOrder, p)

    def toDOM(self, XMLDoc, XMLNode):
        for name in self.dist.keys():
            #print "background: name = ", name, self.dist[name], self.order[name]
            background_elem = XMLDoc.createElement("hmm:background")
            background_elem.setAttribute('key', "%s" % name)
            background_elem.setAttribute('order', "%s" % self.order[name])
            if self.order[name] == 0:
                contents = XMLDoc.createTextNode(csvFromList(self.dist[name]))
            else:
                contents = XMLDoc.createTextNode(csvFromList(self.dist[name],
                                                             self.itsHMM.hmmAlphabets[0].size()))               
            background_elem.appendChild(contents)
            XMLNode.appendChild(background_elem)

    def names(self):
        return self.dist.keys()

   

class XMLElementWriter:
    
    def __init__(self):
        import string
        self._string = string
        self.element_keys = ['id', 'hmm:low', 'hmm:high', 'hmm:type', 'hmm:id','hmm:alphabet_id', 'hmm:name', 'xmlns', 'xmlns:gd', 'xmlns:hmm', 'for', 'gd:type', 'code', 'key', 'order', 'x', 'y', 'source', 'target', 'name', 'domain']
        
    def _write_data(self, writer, data):
        "Writes datachars to writer."
        replace = self._string.replace
        data = str(data)
        data = replace(data, "&", "&")
        data = replace(data, "<", "&lt;")
        data = replace(data, "\"", "&quot;")
        data = replace(data, ">", "&gt;")
        writer.write(data)

    def writexml(self, XMLNode, writer, indent="", addindent="", newl=""): 
        """This version of write xml makes sure text nodes are 
        surrounded by tags for easier reading rather than being 
        on lines by themselves."""  

        # indent = current indentation
        # addindent = indentation to add to higher levels
        # newl = newline string
        
        if ( XMLNode.nodeType == XMLNode.TEXT_NODE ): 
            self._write_data(writer, "%s%s%s"%(indent, XMLNode.data, newl))
        # also handle comments
        elif (XMLNode.nodeType == XMLNode.COMMENT_NODE):
            writer.write("%s<!--" % indent)
            self._write_data(writer, "%s" % XMLNode.nodeValue)
            writer.write("-->%s" % newl)
        else:
            writer.write(indent+"<" + XMLNode.nodeName)
            
            # build attribute list
            a_names = []
            try:
                for key in self.element_keys:
                    if ( XMLNode.getAttribute(key) != ""):
                        a_names.append( key )
                        a_names.sort()
            except AttributeError:
                a_names = []
        
            for a_name in a_names:
                writer.write(" %s=\"" % a_name)
                self._write_data(writer, XMLNode.getAttribute(a_name))
                writer.write("\"")
            if XMLNode.childNodes:
                writer.write(">%s"%(newl))
                for node in XMLNode.childNodes:
                    if node.nodeType!=node.TEXT_NODE: 
                        self.writexml(node,writer,indent+addindent,addindent,newl)
                    else:
                        writer.seek(writer.tell()-1)
                        self.writexml(node,writer,"",addindent,"")

                if XMLNode.childNodes[-1].nodeType!= XMLNode.TEXT_NODE:
                    writer.write("%s</%s>%s" % (indent,XMLNode.nodeName,newl))
                else:
                    writer.write("</%s>%s" % (XMLNode.nodeName,newl))
            else:
                writer.write("/>%s"%(newl))
                     

#
# Notice for this function:
# minidom.Element.toprettyxml is not so pretty and its output format is not compatible
# with XMLIO parser. The particular problem with minidom.toprettyxml is that
# it put the text data of a text node on a new line, instead of immediately after the element tag.
# Because XMLIO cannot parse this format, thus we need our own pretty print program 
#
def toprettyxml( XMLDoc ):
    # we can't use cStringIO since it doesn't support Unicode strings
    from StringIO import StringIO
    writer = StringIO()
    prettydoc = XMLElementWriter()
    writer.write('<?xml version="1.0" ?>\n')
    # remove empty text nodes to make XMLElementWriter work correctly
    removeEmptyTextNodes(XMLDoc)
    for node in XMLDoc.childNodes:
        prettydoc.writexml(node, writer, "","  ", "\n")
    return writer.getvalue();

def removeEmptyTextNodes(XMLNode):
    # some minidom implementations include lots of whitespace text nodes
    # they prevent the XMLWriter from writing nice XML
    if (XMLNode.nodeType == XMLNode.TEXT_NODE):
        if (XMLNode.nodeValue.strip() == ""):
            XMLNode.parentNode.removeChild(XMLNode)
    else:
        # have to copy the list because the removeChild() modifies the list
        import copy
        childNodes = copy.copy(XMLNode.childNodes)
        for child in childNodes:
            removeEmptyTextNodes(child)

class DOM_Map:
    def __init__(self):
        self.initialize()

    def initialize(self):
        self.name = {}
        self.desc = {}
        self.hasDesc = None
        self.name2code = {}
        
    def addCode(self, code, name, desc = None):
        self.name[code] = name
        if desc != None:
            self.desc[code] = desc
            self.hasDesc = 1
        self.name2code[name] = code

    def low(self):
        if len(self.name.keys()) > 0:
            return min(self.name.keys())
        else:
            return 0
                
    def high(self):
        if len(self.name.keys()) > 0:
            return max(self.name.keys())
        else:
            return 0
    
    def fromDOM(self, XMLNode):
        pass

    def symbolsFromDom(self, XMLNode):
        symbols = XMLNode.getElementsByTagName("symbol")
        
        for symbol in symbols:
            symbolCode = ValidatingInt(int(symbol.getAttribute("code")))
            symbolName = ValidatingString(symbol.firstChild.nodeValue)
            symbolDesc = symbol.getAttribute("desc")
            if symbolDesc != None:
                self.addCode(symbolCode, symbolName, ValidatingString(symbolDesc))
            else:
                self.addCode(symbolCode, symbolName)
                
    def toDOM(self, XMLDoc, XMLNode):
        XMLNode.setAttribute('hmm:low', "%s" % self.low())
        XMLNode.setAttribute('hmm:high', "%s" % self.high())
        map = XMLDoc.createElement("map")  
        for key in self.name.keys():
            symbol = XMLDoc.createElement("symbol")
            symbol.setAttribute('code', "%s" % key)
            if self.hasDesc and self.desc[key] != "":
                symbol.setAttribute('desc', "%s" % self.desc[key])
            writeContents(XMLDoc, symbol, "%s" % self.name[key])
            map.appendChild(symbol)
        XMLNode.appendChild(map)
   
    def buildList(self):
	return self.name.keys()
     
# -------------------------------------------
#  Exceptions

class HMMEdError(Exception):
    def __init__(self, message):
	print "\n\n Unknown error types. Please report \n\n"
	
class NotValidHMMType(HMMEdError):
    def __init__(self,message):
       print "\n\n Probabilities missing xception: " + str(message) + "\n"

class AlphabetErrorType(HMMEdError):
    def __init__(self,message):   
        print "\n\n Alphabet exception: " + str(message) + "\n"
	
	
class DiscreteHMMAlphabet(DOM_Map):
    def __init__(self):
        DOM_Map.__init__(self)
        self.hmm_type = 'discrete'
        self.id = 0

    def fromDOM(self, XMLNode):
        """Take dom subtree representing a <hmm:alphabet</hmm:alphabet> element"""
        self.initialize()
        # Not reading: hmm:low hmm:high
        if XMLNode.getAttribute("hmm:type") == self.hmm_type:
            self.symbolsFromDom(XMLNode)
            id = XMLNode.getAttribute("hmm:id")
            if (id != ""):
                self.id = int(id)
        else:
            print "DiscreteHMMAlphabet wrong type %s" % XMLNode.getAttribute("hmm:type") 

    def toDOM(self, XMLDoc, XMLNode):
        hmmalphabet = XMLDoc.createElement("hmm:alphabet")
        hmmalphabet.setAttribute('hmm:type', 'discrete')
	hmmalphabet.setAttribute('hmm:low', "%s" % self.low())
        hmmalphabet.setAttribute('hmm:high', "%s" % self.high())
        hmmalphabet.setAttribute('hmm:id', str(self.id))
        map = XMLDoc.createElement("map")  
        for key in self.name.keys():
            symbol = XMLDoc.createElement("symbol")
            symbol.setAttribute('code', "%s" % key)
            if self.hasDesc and self.desc[key] != "":
                symbol.setAttribute('desc', "%s" % self.desc[key])
            writeContents(XMLDoc, symbol, "%s" % self.name[key])
            map.appendChild(symbol)
        hmmalphabet.appendChild(map)
	#  DOM_Map.toDOM(self, XMLDoc, hmmalphabet)
        XMLNode.appendChild(hmmalphabet)

    def toGHMM(self, XMLDoc, XMLNode):
        hmmalphabet = XMLDoc.createElement("alphabet")
        for key in self.name.keys():
            alphabet = XMLDoc.createElement("symbol")
            alphabet.setAttribute('id', "%s" % key)
            hmmalphabet.appendChild(alphabet)
        XMLNode.appendChild(hmmalphabet)
      
   
    def size(self):
        return len(self.name.keys())
    
    def buildList(self):
	return self.name.keys()