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

import cElementTree as ET
import elementtree.ElementTree as etree
import csml.parser_extra

'''CSML v2 Parser ''' 

#this map needs updating for V2
etree._namespace_map.update({'http://www.opengis.net/om': 'om',  'http://www.opengis.net/gml': 'gml','http://ndg.nerc.ac.uk/csml' : 'csml', 'http://www.w3.org/1999/xlink':'xlink'})


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 __removeURI(self, qname):
        try:
            attname = qname.split('}')[1]
        except IndexError:
            attname = qname
        return attname

    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])
         #but probably need to handle the case where GML attributes are set without namespace
         #to allow for  use of classname(id = 'blah') 
        for item in self.__dict__:
            if GML(item) in self.ATTRIBUTES:
                csmlfrag.set(GML(item), self.__dict__[item])       
         
    # self.CHILDREN (recursive - calls the toXML method of children)
        for att in self.__dict__:
            if att not in ['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 == 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'), GML('description')] # etc
    #ATTRIBUTES not implemented yet.
    

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

class NetCDFExtract(AbstractFileExtract, csElement):
    def __init__(self,**kwargs):
        AbstractFileExtract.__init__(self, **kwargs)
        self.CHILDREN = Merge(self.CHILDREN,{'variableName':[CSML('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.CHILDREN = {'ncExtract':[CSML('NetCDFExtract'), 'NetCDFExtract']}
    def toXML(self):
        csmlfrag=ET.Element(CSML('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)
    csmlout=csml.parser_extra.removeInlineNS(csmlout)
    print csmlout
    #print dir(csmlout)

    #test writing a document from scratch:
    

if __name__=='__main__':
    main()