source: TI02-CSML/branches/CSML2/csParser.py @ 1734

import cElementTree as ET
import csml.parser_extra

'''CSML v2 Parser ''' 


nsCSML = 'http://ndg.nerc.ac.uk/csml'
nsGML = 'http://www.opengis.net/gml'
nsOM = 'http://www.opengis.net/om'
nsXLINK = 'http://www.w3.org/1999/xlink'
nsXML = 'http://ndg.nerc.ac.uk/csml'
nsMOLES='http://ndg.nerc.ac.uk/moles'

def myQName(uri,tag):
    return "{"+uri+"}"+tag

def CSML(tag):
    return myQName(nsCSML,tag)

def GML(tag):
    return myQName(nsGML,tag)

def Merge(dict1, dict2):
    '''merges (adds) two dictionary objects, used in attribute 'inheritance.'''
    dict3={}
    for item in dict1:
        dict3[item] =dict1[item]
    for item in dict2:
        dict3[item] =dict2[item]
    return dict3


class csElement(object):
    ''' main csElement class - all other elements inherit from this baseclass  
    all the from/to XML conversion is done by this class'''
    
    def __init__(self, **kwargs):
        if not hasattr(self, 'ATTRIBUTES'):
            self.ATTRIBUTES=[]
            
    def toXML(self, csmlfrag):
    #process self... and convert  to XML 
        for item in self.__dict__:
            if item in self.ATTRIBUTES:
                csmlfrag.set(item, self.__dict__[item])
    # self.CHILDREN (recursive - calls the toXML method of children)
        for att in self.__dict__:
            if att not in ['NAMESPACE', 'ATTRIBUTES', 'CHILDREN', 'CONTENT']:
                for child in self.CHILDREN:
                    if child == att:
                        #found a match.
                        ename = self.CHILDREN[child][0] #Element Name
                        etype = self.CHILDREN[child][1] #Element Type
                        if type(self.__dict__[att])  is list:
                            for item in self.__dict__[att]:
                                frag=ET.Element(ename)
                                if self.CONTENT is not None:
                                    frag.text=self.CONTENT
                                item.toXML(frag)
                                csmlfrag.append(frag)
                        else:
                            frag=ET.Element(ename)
                            if self.CONTENT is not None:
                                    frag.text=self.CONTENT
                            self.__dict__[att].toXML(frag)
                            csmlfrag.append(frag)
        return csmlfrag
        
    def fromXML(self,csmlfrag):
        # deal with attributes, e.g. gml id's
        for item in csmlfrag.items():
            if item[0] in self.ATTRIBUTES:
                setattr(self, item[0], item[1])
        # self.CHILDREN (recursive - calls the fromXML method of children
        for frag in csmlfrag[:]: 
            if frag.text is not None:
                self.CONTENT = frag.text
            for child in self.CHILDREN:
                ename = self.CHILDREN[child][0] #Element Name 
                if frag.tag == myQName(self.NAMESPACE, ename):
                    etype = self.CHILDREN[child][1]
                    #Element Type                    #elem = ET.Element(ename)
                    childobj=eval(etype)()
                    childobj.fromXML(frag)
                    if hasattr(self, child):
                        if type(self.__dict__[child]) is not list:
                            tmp=self.__dict__[child]
                            setattr(self, child, [tmp]) #convert to list
                        self.__dict__[child].append(childobj)
                    else:
                        setattr(self, child, childobj)

class csString(csElement):
    pass

class AbstractGML(csElement):
   
    def __init__(self, **kwargs):
        self.ATTRIBUTES=[GML('id'), 'description'] # etc
    #ATTRIBUTES not implemented yet.
    

class AbstractFileExtract(AbstractGML, csElement):
    def __init__(self,**kwargs):
        AbstractGML.__init__(self,**kwargs)
        self.NAMESPACE= nsCSML
        self.CHILDREN = {'fileName':['fileName', 'csString']}

class NetCDFExtract(AbstractFileExtract, csElement):
    def __init__(self,**kwargs):
        AbstractFileExtract.__init__(self, **kwargs)
        self.NAMESPACE= nsCSML
        self.CHILDREN = Merge(self.CHILDREN,{'variableName':['variableName', 'csString']})
        #use Merge() when inheriting CHILDREN attribute to extend rather than replace


class Dataset(AbstractGML, csElement):    
    ''' Dataset class, needed as root of tree'''
    def __init__(self, **kwargs):
        AbstractGML.__init__(self,**kwargs)
        self.NAMESPACE=nsCSML
        self.CHILDREN = {'ncExtract':['NetCDFExtract', 'NetCDFExtract']}
    def toXML(self):
        csmlfrag=ET.Element('Dataset')
        csElement.toXML(self, csmlfrag)
        return csmlfrag

def main():
    '''round trip for testing purposes:'''
    tree=ET.ElementTree(file='test.xml')
    ds=Dataset()
    ds.fromXML(tree.getroot())
    csmltree=ds.toXML()
    #print csmltree
    csmlout=csml.parser_extra.PrettyPrint(csmltree)
    print csmlout
    #print dir(csmlout)


if __name__=='__main__':
    main()