Changeset 1810 for TI02-CSML/branches


Ignore:
Timestamp:
05/12/06 09:54:46 (13 years ago)
Author:
domlowe
Message:

main patterns working for parsing referenceableGridCovereage in csml v2 parser

Location:
TI02-CSML/branches/CSML2
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • TI02-CSML/branches/CSML2/csParser.py

    r1756 r1810  
    11import cElementTree as ET 
    22import elementtree.ElementTree as etree 
    3 import csml.parser_extra 
     3import parser_extra 
    44import sys 
    55'''CSML v2 Parser '''  
     
    3333    return myQName(nsXLINK,tag) 
    3434 
    35 def inherit(dict1, dict2): 
    36     '''merges (adds) two dictionary objects, used in attribute 'inheritance.''' 
     35def addchildren(obj, dict): 
     36    ''' merges (adds) dictionary to existing self.CHILDREN dictionary ''' 
     37    dict1 = dict 
     38    if hasattr(obj, 'CHILDREN'): 
     39      dict2=obj.CHILDREN 
     40    else: 
     41      dict2={} 
    3742    dict3={} 
    3843    for item in dict1: 
     
    4045    for item in dict2: 
    4146        dict3[item] =dict2[item] 
    42     return dict3 
     47    obj.CHILDREN=dict3 
     48     
     49 
     50def addatts(obj, atts): 
     51  ''' merges self.ATTRIBUTES''' 
     52  if hasattr(obj, 'ATTRIBUTES'): 
     53    for att in atts: 
     54        obj.ATTRIBUTES.append(att) 
     55  else: 
     56    obj.ATTRIBUTES=atts 
    4357 
    4458class csElement(object): 
     
    5973         
    6074    def _getSubstitutionType(self,tag): 
    61         pass #stub 
     75        return tag 
    6276     
    6377    def _getReverseSubsType(self, typename): 
    64         pass #stub 
    65      
     78        return typename 
     79    
    6680    def toXML(self, csmlfrag): 
    67     #process self... and convert  to XML  
     81        #process self... and convert  to XML  
    6882        if hasattr(self, 'CONTENT'): 
    6983                if self.CONTENT is not None: csmlfrag.text=self.CONTENT 
     
    7892                    csmlfrag.set(GML(item), self.__dict__[item])        
    7993    # self.CHILDREN (recursive - calls the toXML method of children 
    80         for att in self.__dict__: 
     94        for att in self.__dict__:              
    8195            if att not in ['ATTRIBUTES', 'CHILDREN', 'CONTENT']: 
    82                 #print 'ELEMENT: %s'%att 
    8396                for child in self.CHILDREN: 
    84                     if child == att:                
    85                     #    print self.__dict__[att]        
     97                    if child == att:                      
    8698                        #found a match. 
    8799                        if type(self.CHILDREN[child][0]) is not list: 
    88                             ename=self.CHILDREN[child][0]#Element Name 
     100                            ename=self.CHILDREN[child][0]#Element Name     
    89101                        etype = self.CHILDREN[child][1] #Element Type 
    90102                        if type(self.__dict__[att])  is list: 
     
    95107                                csmlfrag.append(frag) 
    96108                        elif len(self.CHILDREN[child])==3: 
    97                             ename2=self.CHILDREN[child][2] 
    98                             parentfrag=ET.Element(ename) 
    99                             frag=ET.Element(ename2) 
    100                             self.__dict__[att].toXML(frag) 
    101                             parentfrag.append(frag) 
    102                             csmlfrag.append(parentfrag) 
    103                             print 'ENAMES' 
    104                             print ename 
    105                             print ename2 
     109                          ename2=self.CHILDREN[child][2] 
     110                          parentfrag=ET.Element(ename) 
     111                          frag=ET.Element(ename2) 
     112                          self.__dict__[att].toXML(frag) 
     113                          parentfrag.append(frag) 
     114                          csmlfrag.append(parentfrag) 
     115                          
    106116                        else: 
    107                             frag=ET.Element(ename) 
    108                             self.__dict__[att].toXML(frag) 
    109                             csmlfrag.append(frag) 
     117                          #this if handles the case eg in FeatureCollection where child maybe one of several types eg [GridFeature, PointFeature] etc. 
     118                          if type(self.CHILDREN[child][0]) is list: 
     119                            item=self.__dict__[att] 
     120                            ename = self._getReverseSubsType(type(item).__name__)  
     121                          else: 
     122                            ename=self.CHILDREN[child][0] 
     123                          frag=ET.Element(ename) 
     124                          self.__dict__[att].toXML(frag) 
     125                          csmlfrag.append(frag) 
    110126                             
    111                              
     127                            
    112128        return csmlfrag 
    113129         
     
    120136         ####################################### 
    121137        # deal with attributes, e.g. gml id's 
    122         if csmlfrag.tag == '{http://ndg.nerc.ac.uk/csml}value': 
    123             print 'VALUE DETAILS - from XML' 
     138        if csmlfrag.tag == '{http://ndg.nerc.ac.uk/csml}ReferenceableGridCoverage': 
     139            print 'RG DETAILS - from XML' 
    124140        if csmlfrag.text is not None: 
    125141                self.CONTENT = csmlfrag.text 
     
    128144        for item in csmlfrag.items(): 
    129145            if item[0] in self.ATTRIBUTES: 
    130                 if csmlfrag.tag == '{http://ndg.nerc.ac.uk/csml}value': 
    131                     print 'attributes %s'%self.ATTRIBUTES 
    132146                setattr(self, item[0], item[1]) 
    133147        # self.CHILDREN (recursive - calls the fromXML method of children 
     
    137151                if frag.tag == ename: 
    138152                    etype = self.CHILDREN[child][1] 
    139                     #Element Type                    #elem = ET.Element(ename) 
    140153                    childobj=eval(etype)() 
    141                     childobj.fromXML(frag) 
     154                    if len(self.CHILDREN[child])==3: 
     155                      if frag[:] != []: 
     156                        childobj.fromXML(frag[0]) 
     157                    else: 
     158                      childobj.fromXML(frag) 
    142159                    if hasattr(self, child): 
    143160                        if type(self.__dict__[child]) is not list: 
     
    147164                    else: 
    148165                        setattr(self, child, childobj) 
     166                     
    149167                if type(ename) is list: # e.g. FeatureCollection where it can be GridFeature, PointFeature etc.. 
    150168                    if frag.tag in ename: 
     
    166184class AbstractGML(csElement): 
    167185    def __init__(self, **kwargs): 
    168         a=[GML('id'), GML('description'), GML('name'), 'MetaDataProperty'] 
     186        a=[GML('id'), GML('description'), GML('name'), GML('MetaDataProperty')] 
     187        addatts(self,a) 
     188 
     189class AssociationAttributeGroup(csElement): 
     190    def __init__(self, **kwargs): 
     191        a =[XLINK('href'),XLINK('role'), XLINK('arcrole'),XLINK('title'), XLINK('show'), XLINK('actuate')]  
     192        addatts(self,a) 
     193 
     194class AbstractFeature(AbstractGML,csElement): 
     195    def __init__(self, **kwargs): 
     196        AbstractGML.__init__(self,**kwargs) 
     197        children={'boundedBy':[GML('boundedBy'), 'Envelope']} 
     198        addchildren(self,children) 
     199         
     200class AbstractFeatureCollection(AbstractFeature,csElement): 
     201    def __init__(self, **kwargs): 
     202        AbstractFeature.__init__(self,**kwargs) 
     203        children={'members':[[CSML('GridFeature'),CSML('PointFeature')], 'AbstractFeature']} 
     204        addchildren(self,children) 
     205         
     206class domainSet(AbstractGML,AssociationAttributeGroup,csElement): 
     207    def __init__(self, **kwargs): 
     208        AbstractGML.__init__(self,**kwargs) 
     209        addchildren(self,{}) 
     210 
     211class ReferenceableGridDomain(domainSet): 
     212    def __init__(self, **kwargs): 
     213        domainSet.__init__(self,**kwargs) 
     214        addchildren(self,{}) 
     215         
     216class AbstractCoverage(AbstractFeature, csElement): 
     217    def __init__(self, **kwargs): 
     218        AbstractFeature.__init__(self,**kwargs) 
     219         
     220class AbstractDiscreteCoverage(AbstractCoverage, csElement): 
     221    def __init__(self, **kwargs): 
     222        AbstractCoverage.__init__(self,**kwargs) 
     223        addchildren(self,{}) 
     224         
     225         
     226class ReferenceableGrid(AbstractGML, AssociationAttributeGroup, csElement): 
     227    def __init__(self, **kwargs): 
     228        AbstractGML.__init__(self,**kwargs) 
     229        AssociationAttributeGroup.__init__(self,**kwargs) 
     230        addchildren(self,{}) 
     231        a=['dimension'] 
     232        addatts(self,a)    
    169233        if hasattr(self, 'ATTRIBUTES'): 
    170234            for att in a: 
     
    172236        else: 
    173237            self.ATTRIBUTES=a 
    174  
    175 class AssociationAttributeGroup(csElement): 
    176     def __init__(self, **kwargs): 
    177         a =[XLINK('href'),XLINK('role'), XLINK('arcrole'),XLINK('title'), XLINK('show'), XLINK('actuate')]  
    178         if hasattr(self, 'ATTRIBUTES'): 
    179             for att in a: 
    180                 self.ATTRIBUTES.append(att) 
    181         else: 
    182             self.ATTRIBUTES=a 
    183  
    184 class AbstractFeature(AbstractGML,csElement): 
    185     def __init__(self, **kwargs): 
    186         AbstractGML.__init__(self,**kwargs) 
    187         self.CHILDREN={'boundedBy':[GML('boundedBy'), 'Envelope']} 
    188  
    189 class AbstractFeatureCollection(AbstractFeature,csElement): 
    190     def __init__(self, **kwargs): 
    191         AbstractFeature.__init__(self,**kwargs) 
    192         self.CHILDREN=inherit(self.CHILDREN,{'members':[[CSML('GridFeature'),CSML('PointFeature')], 'AbstractFeature']}) 
    193   
    194 class domainSet(AbstractGML,AssociationAttributeGroup,csElement): 
    195     def __init__(self, **kwargs): 
    196         AbstractGML.__init__(self,**kwargs) 
    197         self.CHILDREN={} 
    198  
    199 class referenceableGridDomain(domainSet): 
    200     def __init__(self, **kwargs): 
    201         print 'rgd init' 
    202         domainSet.__init__(self,**kwargs) 
    203         self.CHILDREN=inherit(self.CHILDREN,{}) 
    204  
    205 class AbstractCoverage(AbstractFeature, csElement): 
    206     def __init__(self, **kwargs): 
    207         AbstractFeature.__init__(self,**kwargs) 
    208         #self.CHILDREN={} 
    209          
    210 class AbstractDiscreteCoverage(AbstractCoverage, csElement): 
    211     def __init__(self, **kwargs): 
    212         AbstractCoverage.__init__(self,**kwargs) 
    213         self.CHILDREN={} 
    214          
     238       
    215239class ReferenceableGridCoverage(AbstractDiscreteCoverage, csElement): 
    216240    def __init__(self, **kwargs): 
    217241        AbstractDiscreteCoverage.__init__(self,**kwargs) 
    218         self.CHILDREN = inherit(self.CHILDREN,{'referenceableGridDomain':[CSML('referenceableGridDomain'), 'referenceableGridDomain']}) 
     242        children={'referenceableGridDomain':[CSML('referenceableGridDomain'), 'ReferenceableGrid' , CSML('ReferenceableGrid')]} 
     243        addchildren(self,children) 
    219244    def toXML(self,csmlfrag): 
    220         print 'calling toXML' 
    221245        AbstractDiscreteCoverage.toXML(self,csmlfrag)    
    222246    def fromXML(self,csmlfrag): 
    223         print 'calling fromXML' 
    224247        AbstractDiscreteCoverage.fromXML(self,csmlfrag)    
    225248     
     
    227250    def __init__(self, **kwargs): 
    228251        AbstractGML.__init__(self,**kwargs) 
    229         self.CHILDREN = {}  
     252        addchildren(self,{}) 
    230253 
    231254class Phenomenon(Definition,AssociationAttributeGroup): 
     
    233256        Definition.__init__(self,**kwargs) 
    234257        AssociationAttributeGroup.__init__(self,**kwargs) 
    235         self.CHILDREN = {'':[CSML(''), '']}     
     258        children = {'':[CSML(''), '']}     
     259        addchildren(self,children) 
    236260 
    237261         
     
    239263    def __init__(self, **kwargs): 
    240264        AbstractFeature.__init__(self,**kwargs) 
    241         self.CHILDREN=inherit(self.CHILDREN,{'time':[CSML('time'), 'csString'], 'value':[CSML('value'), 'ReferenceableGridCoverage', CSML('ReferenceableGridCoverage')], 'parameter':[CSML('parameter'), 'Phenomenon']}) 
     265        children={'time':[CSML('time'), 'csString'], 'value':[CSML('value'), 'ReferenceableGridCoverage', CSML('ReferenceableGridCoverage')], 'parameter':[CSML('parameter'), 'Phenomenon']} 
     266        addchildren(self,children) 
    242267 
    243268class AbstractFileExtract(AbstractGML, csElement): 
    244269    def __init__(self,**kwargs): 
    245270        AbstractGML.__init__(self,**kwargs) 
    246         self.CHILDREN = {'fileName':[CSML('fileName'), 'csString']} 
     271        children= {'fileName':[CSML('fileName'), 'csString']} 
     272        addchildren(self,children) 
    247273 
    248274class NetCDFExtract(AbstractFileExtract, csElement): 
    249275    def __init__(self,**kwargs): 
    250276        AbstractFileExtract.__init__(self, **kwargs) 
    251         self.CHILDREN = inherit(self.CHILDREN,{'variableName':[CSML('variableName'), 'csString']}) 
    252         #use inherit() when inheriting CHILDREN attribute to extend rather than replace 
     277        children={'variableName':[CSML('variableName'), 'csString']} 
     278        addchildren(self,children) 
    253279 
    254280class FeatureCollection(AbstractFeatureCollection,csElement): 
     
    273299    def __init__(self, **kwargs): 
    274300        AbstractGML.__init__(self,**kwargs) 
    275         self.CHILDREN = {'ncExtract':[CSML('NetCDFExtract'), 'NetCDFExtract'], 'featureCollection':[CSML('featureCollection') ,'FeatureCollection']} 
     301        children = {'ncExtract':[CSML('NetCDFExtract'), 'NetCDFExtract'], 'featureCollection':[CSML('featureCollection') ,'FeatureCollection']} 
     302        addchildren(self,children) 
    276303    def toXML(self): 
    277304        csmlfrag=ET.Element(CSML('Dataset')) 
     
    287314    csmltree=ds.toXML() 
    288315    #print csmltree 
    289     csmlout=csml.parser_extra.PrettyPrint(csmltree) 
    290     csmlout=csml.parser_extra.removeInlineNS(csmlout) 
     316     
     317    csmlout=parser_extra.PrettyPrint(csmltree) 
     318    csmlout=parser_extra.removeInlineNS(csmlout) 
    291319    print '\n %s'% csmlout 
    292     print dir(ds.featureCollection.members[1].value.CHILDREN) 
    293      
    294      
     320    for member in ds.featureCollection.members: 
     321      print dir(member.value) 
     322         
    295323 
    296324if __name__=='__main__': 
  • TI02-CSML/branches/CSML2/test.xml

    r1745 r1810  
    1919            </GridFeature> 
    2020            <GridFeature> 
    21                 <time>12 13 14 15</time> 
    2221                <value> 
    2322                    <ReferencableGridCoverage> 
    24                         <referenceableGridDomain>testdomain</referenceableGridDomain> 
     23                        <referenceableGridDomain> 
     24                          <referenceableGrid  gml:description ="mygrid" dimension                                         ="2" gml:id="ID004"  > 
     25                            </referenceableGrid>ml 
     26                        </referenceableGridDomain> 
    2527                    </ReferencableGridCoverage> 
    2628                </value> 
     29                <time>12 13 14 15</time> 
    2730                <parameter gml:id='blah' xlink:href='http://someurl#blah' xlink:role='somerole'> </parameter> 
    2831            </GridFeature> 
Note: See TracChangeset for help on using the changeset viewer.