source: TI02-CSML/trunk/csml/csml2Moles/molesReadWrite.py @ 2065

#Dominic Lowe, BADC  18 October 2006
#Updated Sue Latham, BADC 6 December 2006 - add dgStructuredKeyword class

import cElementTree as ET
import sys

class xmlSchema(object):
    ''' this class creates a mapping of the xml schema sequences so that it can be referred to when 
    writing out a new moles document - this enables elements to be written in the order specified by the schema
    If a particular sequence mapping can't be found then the elements will be written in whichever order python sees fit.
    It tries various searches of the schema to pick out the sequences (which can be nested)
    '''
    def __init__(self, schema):
        self.sequences={}
        def __addSequence(molesname, sequence):
            '''adds a new sequences to the list, also handles xs:choice'''
            seqlist=[]
            for elem in sequence[:]:
                if elem.attrib.has_key('name'):
                    seqlist.append(elem.attrib['name'])
                if elem.attrib.has_key('ref'):
                    seqlist.append(elem.attrib['ref'].split(':')[1])
                if elem.tag == '{http://www.w3.org/2001/XMLSchema}choice':
                    for subelem in elem[:]:
                        if subelem.attrib.has_key('name'):
                            seqlist.append(subelem.attrib['name'])
            self.sequences[molesname]=seqlist

        for event, elem in ET.iterparse(schema):
            '''look for sequences in complexTypes'''
            if elem.tag == '{http://www.w3.org/2001/XMLSchema}complexType':
                if elem.attrib.has_key('name'):
                    molesclassname= elem.attrib['name']
                    if elem.attrib['name'][-4:]=='Type':
                        molesclassname=molesclassname[:-4]
                    for subelem in elem[:]:
                        if subelem.tag=='{http://www.w3.org/2001/XMLSchema}sequence':
                            __addSequence(molesclassname,subelem)
                            for subsubelem in subelem[:]:
                                if subsubelem.tag=='{http://www.w3.org/2001/XMLSchema}sequence':
                                    __addSequence(molesclassname,subsubelem)
            if elem.tag == '{http://www.w3.org/2001/XMLSchema}element':
                '''Look for parents of complex types - sometimes a complexType is declared but does not have a name and
              the name belongs to the parent 'element' element.'''
                if elem.attrib.has_key('name'):
                    molesclassname= elem.attrib['name']
                    for subelem in elem[:]:
                        if subelem.tag == '{http://www.w3.org/2001/XMLSchema}complexType':
                            for subsubelem in subelem[:]:
                                if subsubelem.tag=='{http://www.w3.org/2001/XMLSchema}sequence':
                                    __addSequence(molesclassname,subsubelem)
            '''this bit handles the use of types. If some element has a name and a type attribute then if that type is complex it has
            the same sequence as the type e.g. <xs:element name="dataModelID" type="moles:dgMetadataIDType">
            need to run iterparse again as this needs to be done when all elements have already been parsed. '''
            for event, elem in ET.iterparse(schema):
                if elem.tag == '{http://www.w3.org/2001/XMLSchema}element':
                    if elem.attrib.has_key('name'):
                        molesclassname= elem.attrib['name']
                        if elem.attrib.has_key('type'):
                            typename=elem.attrib['type']
                            if typename[-4:]=='Type':
                                 typename=typename[:-4].split(':')[1]  #may also be prefixed by moles
                            try:
                                seq=self.sequences[typename]
                                self.sequences[molesclassname]=seq
                            except KeyError:
                                pass  #can't find anything
        
            
    def lookupOrder(self, dict,classname):
        '''takes the attributes in a dictionary and orders them according to the schema sequence'''
        try:
            order=self.sequences[classname]
            #print classname
            #print order
        except KeyError:
            #print 'keyerror %s!'%classname
            order = []
            for key in dict:
                order.append(dict[key]) # if it can't be found an unordered list is returned from the original dictionary items
        return order

class molesElement(object):
    ''' molesElement class - base class of all elements '''
    def __init__(self, namespace=None, **kwargs):
        if namespace !=None:
            self.ns=namespace
        else:
            self.ns = '{http://ndg.nerc.ac.uk/moles}'
        self.__dict__.update(kwargs)
    
    def __combineattributes(self,attname, newChild):
        att = getattr(self,attname)
        if isinstance(att,molesElement):
            setattr(self,attname,[att, newChild])
        else:
            att.append(newChild)
            setattr(self, attname,att)
            
    def _stripNS(self, tagtostrip):
        try:
            elemname=tagtostrip.split('}')[1]
            ns=tagtostrip.split('}')[0]+'}'
        except IndexError:
            elemname=tagtostrip
            ns='{https://ndg.nerc.ac.uk/moles}'
        return elemname, ns
            
        ns=tagtostrip.split('}')[1]
      
    
    def addChildElem(self, childname, childobj):
        #sometimes you want to add a child element but don't know if there is one already. In which case you want to create a list of child objects.
        if hasattr(self, childname):
            currentattribute=getattr(self,childname)
            if type(getattr(self,childname)) is list:
                currentattribute.append(childobj)
            else:
                newlist=[currentattribute]
                newlist.append(childobj)
                setattr(self,childname, newlist)
        else:
            setattr(self,childname, childobj)
    
    def toXML(self,molesFrag, schema=None):
        if schema != None:
            self.schema=schema
        else:
            self.schema=None
        orderedAttribs=schema.lookupOrder(self.__dict__,molesFrag.tag)
        for item in orderedAttribs:
           #print "item in orderedAttribs is %s" %item
           if type(item) is xmlSchema:
                        continue
           if item == '{http://ndg.nerc.ac.uk/moles}':
                continue
           if hasattr(self, item):
                if isinstance(self.__dict__[item], molesElement):
                    frag=ET.Element(item)
                    self.__dict__[item].toXML(frag,schema=self.schema)
                    molesFrag.append(frag)
                elif isinstance(self.__dict__[item], list):
                    for it in self.__dict__[item]:
                        if isinstance(it, molesElement):
                            frag=ET.Element(item)
                            it.toXML(frag, schema=self.schema)
                            molesFrag.append(frag)
                        else:
                            frag=ET.Element(item)
                            frag.text=it
                else:
                    frag=ET.Element(item)
                    frag.text=self.__dict__[item]
                    molesFrag.append(frag)
        return molesFrag
            
    def fromXML(self,molesFrag):
        children = molesFrag.getchildren()
        
        if children ==[]:
            elementWithoutNS, ns=self._stripNS(molesElement.tag)
            setattr(self,elementWithoutNS, molesElement.text)
        if children!=[]:
            for child in children:
                if child.getchildren()!=[]:
                    childWithoutNS, ns=self._stripNS(child.tag)
                    newClass=type(childWithoutNS, (molesElement,),{})
                    newChild=newClass(ns)
                    newChild.fromXML(child)
                    kw=child.tag
                    if hasattr(self, childWithoutNS):
                        self.__combineattributes(childWithoutNS, newChild)
                    else:
                        setattr(self,childWithoutNS, newChild)
                else:
                    childWithoutNS, ns=self._stripNS(child.tag)
                    setattr(self,childWithoutNS, child.text)
        
                    
class dgMetadata(molesElement):    
    def __init__(self, **kwargs):
        molesElement.__init__(self, **kwargs)
        
    def toXML(self):
        self.schema = xmlSchema('ndgmetadata1.3.xsd')
        molesFrag=ET.Element('dgMetadata')
        molesFrag.attrib['xmlns']='http://ndg.nerc.ac.uk/moles'
        molesElement.toXML(self,molesFrag,schema=self.schema)
        return molesFrag


class MolesDoc(object):
    def __init__(self):
        self._createClasses()
    
    def _create_a_class(self,name, base_class):
        aNewClass=type(name, (base_class,),{})
        return aNewClass

    def _createClasses(self):
        #if you want more classes just add their names to this list
        #could probably examine the schema here....
        classList= \
        ['dataModelID', \
        'dgDataGranule', \
        'dgDataEntity', \
        'dgMetadataRecord', \
        'dgMetadataID',
        'dgCoverage', \
        'dgDataCoverage',\
        'dgSpatioTemporalCoverage', \
        'dgSpatialCoverage', \
        'dgTemporalCoverage', \
        'dgBoundingBox', \
        'DateRange', \
        'dgDataSummary', \
        'dgParameterSummary', \
        'dgParameterValue', \
        'dgValueDataParameter', \
        'dgStandardUnit', \
        'dgOriginalUnit', \
        'dgRangeDataParameter', \
        'dgEnumerationParameter', \
        'dgParameterGroup', \
        'dgComponentParameter', \
        'dgStdParameterMeasured', \
        'dgStandardUnit', \
        'dgValidTermID', \
        'dgValidTermParentID', \
        'dgValidSubterm', \
        'metadataDescriptionID', \
        'dgMetadataDescription', \
        'dgStructuredKeyword', \
        ]

        for className in classList:
            newClass=self._create_a_class(className, molesElement)
            setattr(self,className,newClass)