source: TI02-CSML/trunk/csml/parser_extra.py @ 2632

#parser_extra.py
# DL 12 april 2006
#v2 DL 22 November 2006: changed namespaces to reflect v2 schema
# 'extra' functions to enable parsing.
#contains:
#. Namespace fix
# Function to resolve references in CSML doc.

import csml
import csml.parser
import sys
try: #python 2.5
    from xml.etree import ElementTree as etree
except ImportError:
    try:
        # if you've installed it yourself it comes this way
        import ElementTree as etree
    except ImportError:
        # if you've egged it this is the way it comes
        from elementtree import ElementTree as etree
import string
import cElementTree as ET
import codecs


#some xml/string manipulation functions. may as well go in this file for now:

def encodingParser(file, encoding):
    f = codecs.open(file, "r", encoding)
    p = ET.XMLParser(encoding="utf-8")
    while 1:
        s = f.read(65536)
        if not s:
            break
        p.feed(s.encode("utf-8"))
    return ET.ElementTree(p.close())


def PrettyPrint(elem,indent='',html=0,space='   '):
        '''Lightweight pretty printing of elementTree elements'''
        def estrip(elem):
                ''' Just want to get rid of unwanted whitespace '''
                if elem is None:
                        return ''
                else:
                        return elem.strip()
        strAttrib=''
        for att in elem.attrib:
                strAttrib+=' %s="%s"'%(att,elem.attrib[att])
        result='%s<%s%s>%s'%(indent,elem.tag,strAttrib,estrip(elem.text))
        children=len(elem)
        if children:
                for item in elem:
                        result+='\n'+PrettyPrint(item,indent=indent+space)
                result+='\n%s%s</%s>'%(indent,estrip(item.tail),elem.tag)
        else:
                result+='</%s>'%(elem.tag)
        return result

# fixing up namespaces:
def removeInlineNS(csmlstring):
        #  removeInlineNS: function removes "inline" namespaces and declares them as part of the Dataset element.
    
        #replace any fully qualified namespaces
        csmlstring=csmlstring.replace('{http://www.opengis.net/gml}', 'gml:')
        csmlstring=csmlstring.replace('{http://ndg.nerc.ac.uk/csml}','')
        csmlstring=csmlstring.replace('{http://www.w3.org/1999/xlink}','xlink:')
        csmlstring=csmlstring.replace('{http://www.opengis.net/om}','om:')
        csmlstring=csmlstring.replace('{http://www.opengis.net/swe}','swe:')                
        csmlstring=csmlstring.replace('{http://ndg.nerc.ac.uk/moles}','moles:')
        #remove cmsl: prefixes
        csmlstring=csmlstring.replace('<csml:','<')
        csmlstring=csmlstring.replace('</csml:','</')
        
        #add namespace declarations at top of document
        csmlstring=csmlstring.replace('<Dataset', '<Dataset xmlns="http://ndg.nerc.ac.uk/csml"  xmlns:gml="http://www.opengis.net/gml" xmlns:om="http://www.opengis.net/om" xmlns:swe="http://www.opengis.net/swe"  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:moles="http://ndg.nerc.ac.uk/moles"  xmlns:xlink="http://www.w3.org/1999/xlink" xsi:schemaLocation="http://ndg.nerc.ac.uk/csml  csmlDataset.xsd"')
        
        #this is only used when creating a new csml document
        csmlstring=csmlstring.replace('ns0', 'gml')
        csmlstring=csmlstring.replace('xmlns:ns1', 'xmlns:xlink')
        csmlstring=csmlstring.replace('ns1:href', 'xlink:href')
        csmlstring=csmlstring.replace('ns1:moles', 'xlink:moles')
        csmlstring=csmlstring.replace('ns1:', '')  #the rest of the ns1s are CSML namespaces... due to the way it has been parsed.        
        #what about SWE - need to check this ********TODO*****
        return csmlstring


def isURI(uri):
    """ a very simple function to test if a string is a uri 
    if ;// appears in the first 12 characters it is probably a uri """
    #TODO - a decent uri check!    
    result = False
    if string.find(uri[:12], '://') != -1:
        result = True
    return result


class ParserPostProcessor:
    def __init__(self,dataset): 
        
        self.dataset=dataset
        
    def __findFLmatch(self, href):
        for sd in csml.csmllibs.csmlextra.listify(self.dataset.storageDescriptor.descriptors):
            if type(sd)==csml.parser.AggregatedArray:
                for comp in csml.csmllibs.csmlextra.listify(sd.components):
                    if hasattr(comp, 'fileList'):
                        if hasattr(comp.fileList, 'id'):
                            if comp.fileList.id==href:
                                return comp.fileList
        
                        
    def __findSDmatch(self, href):     
        for sd in csml.csmllibs.csmlextra.listify(self.dataset.storageDescriptor.descriptors):
            if type(sd) in [csml.parser.NetCDFExtract, csml.parser.AggregatedArray]:
                if hasattr(sd, 'id'):
                     if sd.id == href:
                        return sd
                        
                
        
    def resolveReferences(self):
        #Need to do this in more simple manner! for each xlink, call csml.csmllibs.csmlxlink.resolveXlink()
        
        #start with fileLists in the the storage descriptors:
        if hasattr(self.dataset, 'storageDescriptor'):
            if hasattr(self.dataset.storageDescriptor, 'descriptors'):
                for sd in csml.csmllibs.csmlextra.listify(self.dataset.storageDescriptor.descriptors):
                    if type(sd)==csml.parser.AggregatedArray:
                        for comp in csml.csmllibs.csmlextra.listify(sd.components):
                            if hasattr(comp, 'fileListXLINK'):
                                if hasattr(comp.fileListXLINK, 'href'):                                
                                    fList = self.__findFLmatch(comp.fileListXLINK.href[1:])
                                    if fList is not None:
                                        comp.fileList =fList
                                        del comp.fileListXLINK
       
        # now handle any xlinks in the domain:
        for feature in csml.csmllibs.csmlextra.listify(self.dataset.featureCollection.featureMembers):
            cvg = feature.value
            for att in ['gridSeriesDomain', 'pointDomain', 'profileSeriesDomain','blah blah']:
                if hasattr(cvg, att):
                    domain=getattr(cvg,att)
                    for ordinate in domain.coordTransformTable.gridOrdinates:
                        if hasattr(ordinate.coordAxisValues,'href'):
                            if ordinate.coordAxisValues.arcrole.split('#')[1] in ['coordinateList', 'timePositionList']:
                                dataforClist= self.__findSDmatch(ordinate.coordAxisValues.href[1:])
                            if dataforClist is not None:
                                    setattr(ordinate.coordAxisValues, 'insertedExtract', dataforClist)
                    break
            
            #now the rangeSet:
            if hasattr(feature.value.rangeSet, 'valueArray'):
                #could be an xlink here..
                for vc in  csml.csmllibs.csmlextra.listify(feature.value.rangeSet.valueArray.valueComponent):
                    if hasattr(vc, 'href'):
                        dataforQlist=self.__findSDmatch(vc.href[1:])
                        if dataforQlist is not None:
                            setattr(vc, 'insertedExtract', dataforQlist)

        return self.dataset