source: TI02-CSML/branches/CSML2/parser.py @ 1896

Subversion URL: http://proj.badc.rl.ac.uk/svn/ndg/TI02-CSML/branches/CSML2/parser.py@1896
Revision 1896, 33.0 KB checked in by domlowe, 14 years ago (diff)

more changes to Scanner and Parser, while getting GridSeries? feature to generate

Line 
1import cElementTree as ET
2import elementtree.ElementTree as etree
3import parser_extra
4import sys
5'''CSML v2 Parser ''' 
6
7#this map needs updating for V2
8etree._namespace_map.update({'http://www.opengis.net/om': 'om', 'http://www.opengis.net/swe': 'swe',  'http://www.opengis.net/gml': 'gml','http://ndg.nerc.ac.uk/csml' : 'csml', 'http://www.w3.org/1999/xlink':'xlink'})
9
10nsCSML = 'http://ndg.nerc.ac.uk/csml'
11nsGML = 'http://www.opengis.net/gml'
12nsOM = 'http://www.opengis.net/om'
13nsXLINK = 'http://www.w3.org/1999/xlink'
14nsXML = 'http://ndg.nerc.ac.uk/csml'
15nsMOLES='http://ndg.nerc.ac.uk/moles'
16nsSWE='http://www.opengis.net/swe'
17   
18def myQName(uri,tag):
19    return "{"+uri+"}"+tag
20
21def CSML(tag):
22    return myQName(nsCSML,tag)
23
24def GML(tag):
25    return myQName(nsGML,tag)
26
27def SWE(tag):
28    return myQName(nsSWE,tag)
29
30def XLINK(tag):
31    return myQName(nsXLINK,tag)
32
33def addchildren(obj, dict):
34    ''' merges (adds) dictionary to existing self.CHILDREN dictionary '''
35    dict1 = dict
36    if hasattr(obj, 'CHILDREN'):
37      dict2=obj.CHILDREN
38    else:
39      dict2={}
40    dict3={}
41    for item in dict1:
42        dict3[item] =dict1[item]
43    for item in dict2:
44        dict3[item] =dict2[item]
45    obj.CHILDREN=dict3
46   
47
48def addatts(obj, atts):
49  ''' merges self.ATTRIBUTES'''
50  if hasattr(obj, 'ATTRIBUTES'):
51    for att in atts:
52        obj.ATTRIBUTES.append(att)
53  else:
54    obj.ATTRIBUTES=atts
55
56
57#Some variable definitions: these things are often repeated so store in variables.
58FILEFORMATS=[CSML('NetCDFExtract'),CSML('NASAAmesExtract'), CSML('GRIBExtract'),CSML('CDMLExtract'), CSML('RawFileExtract')]
59 
60
61class csElement(object):
62    ''' main csElement class - all other elements inherit from this baseclass 
63    all the from/to XML conversion is done by this class'''
64   
65    def __init__(self, **kwargs):
66        if not hasattr(self, 'ATTRIBUTES'):
67            self.ATTRIBUTES=[]
68           
69       
70    def __removeURI(self, qname):
71        try:
72            attname = qname.split('}')[1]
73        except IndexError:
74            attname = qname
75        return attname
76       
77    def _getSubstitutionType(self,tag):
78        print 'splitting tag'
79        return tag.split('}')[1]
80       
81   
82    def _getReverseSubsType(self, typename):
83        return typename
84   
85    def addChildElem(self, childname, childobj):
86        #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.
87        if hasattr(self, childname):
88            currentattribute=getattr(self,childname)
89            if type(getattr(self,childname)) is list:
90                currentattribute.append(childobj)
91            else:
92                newlist=[currentattribute]
93                newlist.append(childobj)
94                setattr(self,childname, newlist)
95        else:
96            setattr(self,childname, childobj)
97
98    def toXML(self, csmlfrag):
99        #process self and convert to XML
100        if hasattr(self, 'CONTENT'):
101            if self.CONTENT is not None: csmlfrag.text=self.CONTENT
102        if hasattr(self, 'ATTRIBUTES'):
103            for item in self.__dict__:
104                if item in self.ATTRIBUTES:
105                    csmlfrag.set(item, self.__dict__[item])
106            for item in self.__dict__:
107                if GML(item) in self.ATTRIBUTES:
108                    csmlfrag.set(GML(item), self.__dict__[item])       
109    # self.CHILDREN (recursive - calls the toXML method of children
110        for att in self.__dict__:
111            if att not in ['ATTRIBUTES', 'CHILDREN', 'CONTENT']:
112                for child in self.CHILDREN:
113                    if child == att:
114                        parserobjects=[]
115                        if type(self.__dict__[att]) is list:
116                            for a in self.__dict__[att]:
117                                parserobjects.append(a)
118                        else:
119                            parserobjects.append(self.__dict__[att])
120                        parentfrag=None
121                        if len(self.CHILDREN[child])>=3:
122                                ename2=self.CHILDREN[child][2]
123                                parentfrag=ET.Element(ename2)
124                        for po in parserobjects:
125                            if type(self.CHILDREN[child][0]) is not list:
126                                ename=self.CHILDREN[child][0]
127                            else:
128                                ename = self._getReverseSubsType(type(po).__name__)
129                            if len(self.CHILDREN[child])==3:
130                                frag=ET.Element(ename)
131                                po.toXML(frag)
132                                parentfrag.append(frag)
133                                appendLater=True
134                            elif len(self.CHILDREN[child])>=4:
135                                if self.CHILDREN[child][3]==1:
136                                    frag=ET.Element(ename)
137                                    po.toXML(frag)
138                                    parentfrag.append(frag)
139                                    csmlfrag.append(parentfrag)
140                                    parentfrag=ET.Element(parentfrag.tag)
141                                    appendLater=False
142                            else:
143                                frag=ET.Element(ename)
144                                po.toXML(frag)
145                                csmlfrag.append(frag)
146                                appendLater=True
147                        if appendLater==True and parentfrag != None:
148                            csmlfrag.append(parentfrag)
149        return csmlfrag
150       
151    def fromXML(self,csmlfrag):
152        # deal with attributes, e.g. gml id's
153        if csmlfrag.text is not None:
154                self.CONTENT = csmlfrag.text
155        for item in csmlfrag.items():
156            if item[0] in self.ATTRIBUTES:
157                setattr(self, item[0], item[1])
158        # self.CHILDREN (recursive - calls the fromXML method of children
159        for frag in csmlfrag[:]:
160            #for each child element
161            #iterate through expected CHILDREN
162            for child in self.CHILDREN:
163                #get element name
164                if len(self.CHILDREN[child])>=3:
165                    ename = self.CHILDREN[child][2]
166                    ename2 = self.CHILDREN[child][0]
167                   
168                else:
169                    ename = self.CHILDREN[child][0] 
170                    ename2=None
171                #if there are options, then find the name that matches the frag
172                if ename2 is not None:
173                    if frag[:] != []:
174                        for subfrag in frag[:]:
175                            etype=None
176                            if type(ename2) is list:
177                                if subfrag.tag in ename2:
178                                    etype=self._getSubstitutionType(subfrag.tag)
179                            if subfrag.tag==ename2:
180                                etype=self.CHILDREN[child][1]
181                            if etype:
182                                childobj=eval(etype)()
183                                if len(self.CHILDREN[child])>=3:
184                                    if frag[:] != []:
185                                        childobj.fromXML(subfrag)
186                                else:
187                                    childobj.fromXML(frag)
188                                #set this object to be an attribute of the 'parent' (self) object
189                                if hasattr(self, child):
190                                    if type(self.__dict__[child]) is not list:
191                                        tmp=self.__dict__[child]
192                                        setattr(self, child, [tmp]) #convert to list
193                                    self.__dict__[child].append(childobj)
194                                else:
195                                    setattr(self, child, childobj)
196                else:
197                    etype=None
198                    if type(ename) is list:
199                        if frag.tag in ename:
200                            etype=self._getSubstitutionType(frag.tag)
201                    elif frag.tag==ename:
202                        etype=self.CHILDREN[child][1]
203                    if etype:
204                        childobj=eval(etype)()
205                        if len(self.CHILDREN[child])>=3:
206                            if frag[:] != []:
207                                childobj.fromXML(frag[0])
208                        else:
209                            childobj.fromXML(frag)
210                        #set this object to be an attribute of the 'parent' (self) object
211                        if hasattr(self, child):
212                            if type(self.__dict__[child]) is not list:
213                                tmp=self.__dict__[child]
214                                setattr(self, child, [tmp]) #convert to list
215                            self.__dict__[child].append(childobj)
216                        else:
217                            setattr(self, child, childobj)
218
219               
220class csString(csElement):
221    def __init__(self, text=None,**kwargs):
222        if text != None:
223            self.CONTENT=text
224        children={}
225        addchildren(self,children)
226   
227class AbstractGML(csElement):
228    def __init__(self, **kwargs):
229        a=[GML('id'), GML('description'), GML('name'), GML('MetaDataProperty')]
230        addatts(self,a)
231
232class AssociationAttributeGroup(csElement):
233    def __init__(self, **kwargs):
234        a =[XLINK('href'),XLINK('role'), XLINK('arcrole'),XLINK('title'), XLINK('show'), XLINK('actuate')] 
235        addatts(self,a)
236
237class SRSReferenceGroup(csElement):
238    def __init__(self, **kwargs):
239        a =['srsName','srsDimension'] 
240        addatts(self,a)
241       
242class SRSInformationGroup(csElement):
243    def __init__(self, **kwargs):
244        a =['uomLabels','axisLabels'] 
245        addatts(self,a)
246
247class ArrayDescriptor(AbstractGML, csElement):
248    def __init__(self,**kwargs):
249        AbstractGML.__init__(self,**kwargs)
250        children={'arraySize':[CSML('arraySize'), 'csString'], 'uom':[CSML('uom'),'csString'], 'numericType':[CSML('numericType'),'csString'], 'regExpTransform':[CSML('regExpTransform'),'csString'], 'numericTransform':[CSML('numericTransform'),'csString']}
251        addchildren(self,children)
252
253class DirectPosition(AbstractGML, SRSReferenceGroup,SRSInformationGroup,csElement):
254    def __init__(self, **kwargs):
255        AbstractGML.__init__(self,**kwargs)
256
257class GridEnvelope(AbstractGML,SRSReferenceGroup, csElement):
258    def __init__(self, **kwargs):
259        SRSReferenceGroup.__init__(self,**kwargs)
260        AbstractGML.__init__(self,**kwargs)
261        children={'low':[GML('low'), 'csString'],'high':[GML('high'), 'csString']}
262        addchildren(self,children)
263
264class Envelope(AbstractGML,SRSReferenceGroup, csElement):
265    def __init__(self, **kwargs):
266        SRSReferenceGroup.__init__(self,**kwargs)
267        AbstractGML.__init__(self,**kwargs)
268        children={'lowerCorner':[GML('lowerCorner'), 'DirectPosition'],'upperCorner':[GML('upperCorner'), 'DirectPosition']}
269        addchildren(self,children)
270
271
272class AbstractFeature(AbstractGML,csElement):
273    def __init__(self, **kwargs):
274        AbstractGML.__init__(self,**kwargs)
275        children={'boundedBy':[GML('boundedBy'), 'Envelope']}
276        addchildren(self,children)
277
278class AbstractFeatureCollection(AbstractFeature,csElement):
279    def __init__(self, **kwargs):
280        AbstractFeature.__init__(self,**kwargs)
281
282class DomainSet(AbstractGML,AssociationAttributeGroup,csElement):
283    def __init__(self, **kwargs):
284        AbstractGML.__init__(self,**kwargs)
285        addchildren(self,{})
286
287class AggregatedArray(ArrayDescriptor,csElement):
288    def __init__(self, **kwargs):
289        ArrayDescriptor.__init__(self,**kwargs)
290        children={'aggType':[CSML('aggType'),'csString'], 'aggIndex':[CSML('aggIndex'),'csString'],'components':[FILEFORMATS, 'ArrayDescriptor',CSML('component')]}
291        addchildren(self,children)
292#'component':[CSML:('component'), 'ArrayDescriptor', CSML('component')],
293class MeasureOrNullList(AbstractGML,csElement):
294    def __init__(self, **kwargs):
295        AbstractGML.__init__(self,**kwargs)
296        children={}
297        addchildren(self,children)
298       
299class CompositeValue(AbstractGML,csElement):
300    def __init__(self, **kwargs):
301        AbstractGML.__init__(self,**kwargs)
302        children={'measures':[GML('measure'),'csString',GML('valueComponents')]}
303        addchildren(self,children)
304       
305class DataBlock(AbstractGML,csElement):
306    #THIS IS INCOMPLETE
307    def __init__(self, **kwargs):
308        AbstractGML.__init__(self,**kwargs)
309        children={'doubleOrNullTupleList':[GML('doubleOrNullTupleList'),'csString'],'rangeParameters':[GML('CompositeValue'), 'CompositeValue', GML('rangeParameters')]}
310        addchildren(self,children)
311
312class RangeSet(AbstractGML,AssociationAttributeGroup,csElement):
313    def __init__(self, **kwargs):
314        AbstractGML.__init__(self,**kwargs)
315        children={'quantityList':[GML('QuantityList'), 'MeasureOrNullList'],        'dataBlock':[GML('DataBlock'),'DataBlock'],'arrayDescriptor':[FILEFORMATS, 'ArrayDescriptor'],  'aggregatedArray':[CSML('AggregatedArray'), 'AggregatedArray']}
316        addchildren(self,children)
317
318class MultiPoint(AbstractGML, SRSReferenceGroup,csElement):
319    def __init__(self, **kwargs):
320        AbstractGML.__init__(self,**kwargs)
321        SRSReferenceGroup.__init__(self,**kwargs)
322        children={'pointMember':[GML('pointMember'), 'csString'],'pointMembers':[GML('pointMember'), 'csString']}
323        addchildren(self,children)
324
325class Point(AbstractGML,SRSReferenceGroup,csElement):
326    def __init__(self, **kwargs):
327        AbstractGML.__init__(self,**kwargs)
328        SRSReferenceGroup.__init__(self,**kwargs)
329        children={'pos':[GML('pos'), 'csString'],'coordinates':[GML('coordinates'), 'csString']}
330        addchildren(self,children)
331
332class PointDomain(DomainSet, MultiPoint,csElement):
333    def __init__(self, **kwargs):
334        DomainSet.__init__(self,**kwargs)
335        MultiPoint.__init__(self,**kwargs)
336        children={}
337        addchildren(self,children)
338
339class ProfileDomain(DomainSet, MultiPoint,csElement):
340    def __init__(self, **kwargs):
341        DomainSet.__init__(self,**kwargs)
342        MultiPoint.__init__(self,**kwargs)
343        children={}
344        addchildren(self,children)
345
346
347
348class AbstractCoverage(AbstractFeature, csElement):
349    def __init__(self, **kwargs):
350        AbstractFeature.__init__(self,**kwargs)
351
352class AbstractDiscreteCoverage(AbstractCoverage, csElement):
353    def __init__(self, **kwargs):
354        AbstractCoverage.__init__(self,**kwargs)
355        addchildren(self,{})
356       
357class Definition(AbstractGML):
358    def __init__(self, **kwargs):
359        AbstractGML.__init__(self,**kwargs)
360        addchildren(self,{})
361
362class Phenomenon(Definition,AssociationAttributeGroup):
363    def __init__(self, **kwargs):
364        Definition.__init__(self,**kwargs)
365        AssociationAttributeGroup.__init__(self,**kwargs)
366        children = {'':[CSML(''), '']}   
367        addchildren(self,children)
368       
369class SpatialOrTemporalPositionList(AbstractGML,csElement):
370    def __init__(self, **kwargs):
371        AbstractGML.__init__(self,**kwargs)
372        children={'coordinateList':[CSML('coordinateList'),'csString'], 'timePositionList':[CSML('timePositionList'),'csString']}
373        addchildren(self,children)
374        a=['frame']
375        addatts(self,a)
376
377class GridOrdinateDescription(AbstractGML,csElement):
378    def __init__(self, **kwargs):
379        AbstractGML.__init__(self,**kwargs)
380        children={'coordAxisLabel':[CSML('coordAxisLabel'), 'csString'], 'coordAxisValues':[CSML('SpatialOrTemporalPositionList'),'SpatialOrTemporalPositionList',CSML('coordAxisValues')], 'gridAxesSpanned':[CSML('gridAxesSpanned'), 'csString'], 'sequenceRule':[CSML('sequenceRule'),'SequenceRuleType']}
381        addchildren(self,children)
382
383class SequenceRuleType(csElement):
384    def __init__(self, **kwargs):
385        a=['axisOrder']
386        addatts(self,a)
387        children={}
388        addchildren(self,children)
389
390class GridPointDescription(AbstractGML,csElement):
391    def __init__(self, **kwargs):
392        AbstractGML.__init__(self,**kwargs)
393        children={'posList':[CSML('posList'),'csString'],'sequenceRule':[CSML('sequenceRule'),'SequenceRuleType']}
394        addchildren(self,children)
395
396
397class TimePositionList(AbstractGML,csElement):
398    def __init__(self,**kwargs):
399        a=['frame', 'calendarEraName','indeterminatePosition']
400        addatts(self,a)
401   
402
403class GridCoordinatesTable(AbstractGML,csElement):
404    def __init__(self,**kwargs):
405        '''the additional value '1' in the children dictionary is used to signify that the elements must be nested as:
406        <gml:ordinate>
407            <gml:GridOrdinateDescription>
408        </gml:ordinate>
409        <gml:ordinate>
410            <gml:GridOrdinateDescription>
411        </gml:ordinate>
412       
413        not as:
414        <gml:ordinate>
415            <gml:GridOrdinateDescription>
416            <gml:GridOrdinateDescription>
417        </gml:ordinate> '''
418        AbstractGML.__init__(self,**kwargs)
419        children={'gridOrdinates':[CSML('GridOrdinateDescription'), 'GridOrdinateDescription',CSML('gridOrdinate'),1], 'gridPoints':[CSML('GridPointDescription'),'GridPointDescription',CSML('gridPoints')]}
420        addchildren(self,children)
421       
422class ReferenceableGrid(AbstractGML, AssociationAttributeGroup, csElement):
423    def __init__(self, **kwargs):
424        AbstractGML.__init__(self,**kwargs)
425        AssociationAttributeGroup.__init__(self,**kwargs)
426        children={'coordTransformTable':[CSML('GridCoordinatesTable'), 'GridCoordinatesTable', CSML('coordTransformTable')],'axisLabels':[CSML('axisLabels'),'csString'], 'limits':[GML('GridEnvelope'),'GridEnvelope',CSML('limits')]}
427        addchildren(self,children)
428        a=['dimension']
429        addatts(self,a)
430
431class ReferenceableGridCoverage(AbstractDiscreteCoverage, csElement):
432    def __init__(self, **kwargs):
433        AbstractDiscreteCoverage.__init__(self,**kwargs)
434        children={'referenceableGridDomain':[CSML('ReferenceableGrid'),'ReferenceableGrid' ,CSML('referenceableGridDomain') ]}
435        addchildren(self,children)
436       
437class AlternatePointCoverage(AbstractDiscreteCoverage, csElement):
438    def __init__(self, **kwargs):
439        AbstractDiscreteCoverage.__init__(self,**kwargs)
440        children={'alternatePointDomain':[GML('Point'),'Point', CSML('alternatePointDomain')], 'rangeSet':[GML('rangeSet'), 'RangeSet'],'coverageFunction':[GML('coverageFunction'),'csString']}
441        addchildren(self,children)
442        print self.CHILDREN
443
444
445class ProfileCoverage(AbstractDiscreteCoverage, csElement):
446    def __init__(self, **kwargs):
447        AbstractDiscreteCoverage.__init__(self,**kwargs)
448        children={'profileDomain':[CSML('ProfileDomain'),'ProfileDomain' ,CSML('profileDomain') ], 'rangeSet':[GML('rangeSet'), 'RangeSet'],'coverageFunction':[GML('coverageFunction'),'csString']}
449        addchildren(self,children)
450
451class PointCoverage(AbstractDiscreteCoverage, csElement):
452    def __init__(self, **kwargs):
453        AbstractDiscreteCoverage.__init__(self,**kwargs)
454        children={'pointDomain':[CSML('PointDomain'),'PointDomain' ,CSML('pointDomain') ], 'rangeSet':[GML('rangeSet'), 'RangeSet'],'coverageFunction':[GML('coverageFunction'),'csString']}
455        addchildren(self,children)
456       
457class TimeSeriesDomain(AbstractGML, csElement):
458    def __init__(self, **kwargs):
459        AbstractGML.__init__(self,**kwargs)
460        children={'time':[CSML('time'), 'csString']}
461        addchildren(self,children)
462       
463
464class PointSeriesCoverage(AbstractDiscreteCoverage, csElement):
465    def __init__(self, **kwargs):
466        AbstractDiscreteCoverage.__init__(self,**kwargs)
467        children={'pointSeriesDomain':[CSML('TimeSeriesDomain'),'TimeSeriesDomain' ,CSML('pointSeriesDomain') ], 'rangeSet':[GML('rangeSet'), 'RangeSet'],'coverageFunction':[GML('coverageFunction'),'csString']}
468        addchildren(self,children)
469
470class ProfileSeriesDomain(ReferenceableGrid, DomainSet, csElement):
471    def __init__(self, **kwargs):
472        DomainSet.__init__(self,**kwargs)
473        ReferenceableGrid.__init__(self,**kwargs)
474        children={}
475        addchildren(self,children)
476
477class ProfileSeriesCoverage(AbstractDiscreteCoverage,csElement):
478    def __init__(self, **kwargs):
479        AbstractDiscreteCoverage.__init__(self,**kwargs)
480        children={'profileSeriesDomain':[CSML('ProfileSeriesDomain'),'ProfileSeriesDomain' ,CSML('profileSeriesDomain') ], 'rangeSet':[GML('rangeSet'), 'RangeSet'],'coverageFunction':[GML('coverageFunction'),'csString']}
481        addchildren(self,children)
482       
483class SectionDomain(ReferenceableGrid, DomainSet, csElement):
484    def __init__(self, **kwargs):
485        DomainSet.__init__(self,**kwargs)
486        ReferenceableGrid.__init__(self,**kwargs)
487        children={}
488        addchildren(self,children)
489       
490class SectionCoverage(AbstractDiscreteCoverage,csElement):
491    def __init__(self, **kwargs):
492        AbstractDiscreteCoverage.__init__(self,**kwargs)
493        children={'sectionDomain':[CSML('SectionDomain'),'SectionDomain' ,CSML('sectionDomain') ], 'rangeSet':[GML('rangeSet'), 'RangeSet'],'coverageFunction':[GML('coverageFunction'),'csString']}
494        addchildren(self,children)
495
496class TrajectoryDomain(ReferenceableGrid, DomainSet, csElement):
497    def __init__(self, **kwargs):
498        DomainSet.__init__(self,**kwargs)
499        ReferenceableGrid.__init__(self,**kwargs)
500        children={}
501        addchildren(self,children)
502       
503class TrajectoryCoverage(AbstractDiscreteCoverage,csElement):
504    def __init__(self, **kwargs):
505        AbstractDiscreteCoverage.__init__(self,**kwargs)
506        children={'trajectoryDomain':[CSML('TrajectoryDomain'),'TrajectoryDomain' ,CSML('trajectoryDomain') ], 'rangeSet':[GML('rangeSet'), 'RangeSet'],'coverageFunction':[GML('coverageFunction'),'csString']}
507        addchildren(self,children)
508
509
510class ScanningRadarDomain(ReferenceableGrid, DomainSet, csElement):
511    def __init__(self, **kwargs):
512        DomainSet.__init__(self,**kwargs)
513        ReferenceableGrid.__init__(self,**kwargs)
514        children={}
515        addchildren(self,children)
516       
517class ScanningRadarCoverage(AbstractDiscreteCoverage,csElement):
518    def __init__(self, **kwargs):
519        AbstractDiscreteCoverage.__init__(self,**kwargs)
520        children={'scanningRadarDomain':[CSML('ScanningRadarDomain'),'ScanningRadarDomain' ,CSML('scanningRadarDomain') ], 'rangeSet':[GML('rangeSet'), 'RangeSet'],'coverageFunction':[GML('coverageFunction'),'csString']}
521        addchildren(self,children)
522
523
524class GridSeriesDomain(ReferenceableGrid, DomainSet, csElement):
525    def __init__(self, **kwargs):
526        DomainSet.__init__(self,**kwargs)
527        ReferenceableGrid.__init__(self,**kwargs)
528        children={}
529        addchildren(self,children)
530       
531class GridSeriesCoverage(AbstractDiscreteCoverage,csElement):
532    def __init__(self, **kwargs):
533        AbstractDiscreteCoverage.__init__(self,**kwargs)
534        children={'gridSeriesDomain':[CSML('GridSeriesDomain'),'GridSeriesDomain' ,CSML('gridSeriesDomain') ], 'rangeSet':[GML('rangeSet'), 'RangeSet'],'coverageFunction':[GML('coverageFunction'),'csString']}
535        addchildren(self,children)
536
537class AlternatePointFeature(AbstractFeature, csElement):
538    def __init__(self, **kwargs):
539        AbstractFeature.__init__(self,**kwargs)
540        children={'location':[CSML('location'), 'csString'],'time':[CSML('time'), 'csString'], 'value':[CSML('AlternatePointCoverage'), 'AlternatePointCoverage', CSML('value')], 'parameter':[CSML('parameter'), 'Phenomenon']}
541        addchildren(self,children)
542
543class PointFeature(AbstractFeature, csElement):
544    def __init__(self, **kwargs):
545        AbstractFeature.__init__(self,**kwargs)
546        children={'location':[CSML('location'), 'csString'],'time':[CSML('time'), 'csString'], 'value':[CSML('PointCoverage'), 'PointCoverage', CSML('value')], 'parameter':[CSML('parameter'), 'Phenomenon']}
547        addchildren(self,children)
548
549class PointCollectionFeature(AbstractFeature, csElement):
550    def __init__(self, **kwargs):
551        AbstractFeature.__init__(self,**kwargs)
552        children={'time':[CSML('time'), 'csString'], 'value':[CSML('MultiPointCoverage'), 'MultiPointCoverage', CSML('value')], 'parameter':[CSML('parameter'), 'Phenomenon']}
553        addchildren(self,children)
554
555
556class PointSeriesFeature(AbstractFeature, csElement):
557    def __init__(self, **kwargs):
558        AbstractFeature.__init__(self,**kwargs)
559        children={'location':[CSML('location'), 'csString'], 'value':[CSML('PointSeriesCoverage'), 'PointSeriesCoverage', CSML('value')], 'parameter':[CSML('parameter'), 'Phenomenon']}
560        addchildren(self,children)
561
562
563class GridFeature(AbstractFeature, csElement):
564    def __init__(self, **kwargs):
565        AbstractFeature.__init__(self,**kwargs)
566        children={'time':[CSML('time'), 'csString'], 'value':[CSML('ReferenceableGridCoverage'), 'ReferenceableGridCoverage', CSML('value')], 'parameter':[CSML('parameter'), 'Phenomenon']}
567        addchildren(self,children)
568
569class GridSeriesFeature(AbstractFeature, csElement):
570    def __init__(self, **kwargs):
571        AbstractFeature.__init__(self,**kwargs)
572        children={'value':[CSML('GridSeriesCoverage'), 'GridSeriesCoverage', CSML('value')], 'parameter':[CSML('parameter'), 'Phenomenon']}
573        addchildren(self,children)
574
575class ProfileFeature(AbstractFeature, csElement):
576    def __init__(self, **kwargs):
577        AbstractFeature.__init__(self,**kwargs)
578        children={'time':[CSML('time'), 'csString'],'location':[CSML('location'), 'csString'], 'value':[CSML('ProfileCoverage'), 'ProfileCoverage', CSML('value')], 'parameter':[CSML('parameter'), 'Phenomenon']}
579        addchildren(self,children)
580
581class ProfileSeriesFeature(AbstractFeature, csElement):
582    def __init__(self, **kwargs):
583        AbstractFeature.__init__(self,**kwargs)
584        children={'location':[CSML('location'), 'csString'], 'value':[CSML('ProfileSeriesCoverage'), 'ProfileSeriesCoverage', CSML('value')], 'parameter':[CSML('parameter'), 'Phenomenon']}
585        addchildren(self,children)
586
587class RaggedProfileSeriesFeature(AbstractFeature, csElement):
588    def __init__(self, **kwargs):
589        AbstractFeature.__init__(self,**kwargs)
590        children={'location':[CSML('location'), 'csString'], 'profileLength':[CSML('profileLength'), 'csString'],'value':[CSML('ProfileSeriesCoverage'), 'ProfileSeriesCoverage', CSML('value')], 'parameter':[CSML('parameter'), 'Phenomenon']}
591        addchildren(self,children)
592
593class RaggedSectionFeature(AbstractFeature, csElement):
594    def __init__(self, **kwargs):
595        AbstractFeature.__init__(self,**kwargs)
596        children={'stationLocations':[CSML('stationLocations'), 'csString'], 'stationTimes':[CSML('stationTimes'), 'csString'],'profileLength':[CSML('profileLength'),'csString'],'value':[CSML('SectionCoverage'), 'SectionCoverage', CSML('value')], 'parameter':[CSML('parameter'), 'Phenomenon']}
597        addchildren(self,children)
598
599class SectionFeature(AbstractFeature, csElement):
600    def __init__(self, **kwargs):
601        AbstractFeature.__init__(self,**kwargs)
602        children={'stationLocations':[CSML('stationLocations'), 'csString'], 'stationTimes':[CSML('stationTimes'), 'TimePositionList'],'value':[CSML('SectionCoverage'), 'SectionCoverage', CSML('value')], 'parameter':[CSML('parameter'), 'Phenomenon']}
603        addchildren(self,children)
604
605
606
607
608class ScanningRadarFeature(AbstractFeature, csElement):
609    def __init__(self, **kwargs):
610        AbstractFeature.__init__(self,**kwargs)
611        children={'elevation':[CSML('elevation'), 'csString'], 'value':[CSML('ScanningRadarCoverage'), 'ScanningRadarCoverage', CSML('value')], 'parameter':[CSML('parameter'), 'Phenomenon']}
612        addchildren(self,children)
613
614class SwathFeature(AbstractFeature, csElement):
615    def __init__(self, **kwargs):
616        AbstractFeature.__init__(self,**kwargs)
617        children={'eqCrossLon':[CSML('eqCrossLon'), 'csString'],'eqCrossTime':[CSML('eqCrossTime'), 'csString'], 'value':[CSML('ReferenceableGridCoverage'), 'ReferenceableGridCoverage', CSML('value')], 'parameter':[CSML('parameter'), 'Phenomenon']}
618        addchildren(self,children)
619
620class TrajectoryFeature(AbstractFeature, csElement):
621    def __init__(self, **kwargs):
622        AbstractFeature.__init__(self,**kwargs)
623        children={'value':[CSML('TrajectoryCoverage'), 'TrajectoryCoverage', CSML('value')], 'parameter':[CSML('parameter'), 'Phenomenon']}
624        addchildren(self,children)
625
626class FileExtract(ArrayDescriptor, csElement):
627    def __init__(self,**kwargs):
628        ArrayDescriptor.__init__(self,**kwargs)
629        children= {'fileName':[CSML('fileName'), 'csString']}
630        addchildren(self,children)
631
632class NetCDFExtract(FileExtract, csElement):
633    def __init__(self,**kwargs):
634        FileExtract.__init__(self, **kwargs)
635        children={'variableName':[CSML('variableName'), 'csString']}
636        addchildren(self,children)
637
638class NASAAmesExtract(FileExtract, csElement):
639    def __init__(self,**kwargs):
640        FileExtract.__init__(self, **kwargs)
641        children={'variableName':[CSML('variableName'), 'csString'], 'index':[CSML('index'),'csString']}
642        addchildren(self,children)
643
644class FeatureCollection(AbstractFeatureCollection,csElement):
645    def __init__(self,**kwargs):
646        AbstractFeatureCollection.__init__(self,**kwargs)
647        children={'members':[[CSML('GridFeature'), CSML('GridSeriesFeature'),CSML('PointFeature'),CSML('TrajectoryFeature'),CSML('ProfileFeature'),CSML('ProfileSeriesFeature'),CSML('RaggedProfileSeriesFeature'),CSML('RaggedSectionFeature'),CSML('SectionFeature'),CSML('ScanningRadarFeature'),CSML('PointSeriesFeature'),CSML('AlternatePointFeature')], 'AbstractFeature', GML('featureMembers')]}
648        addchildren(self,children)
649    def _getSubstitutionType(self,tag):
650        if tag==CSML('GridFeature'):
651            return 'GridFeature'
652        elif tag==CSML('GridSeriesFeature'):
653            return 'GridSeriesFeature'
654        elif tag==CSML('PointFeature'):
655            return 'PointFeature'
656        elif tag==CSML('TrajectoryFeature'):
657            return 'TrajectoryFeature'
658        elif tag==CSML('PointSeriesFeature'):
659            return 'PointSeriesFeature'
660        elif tag==CSML('ProfileFeature'):
661            return 'ProfileFeature'
662        elif tag==CSML('ProfileSeriesFeature'):
663            return 'ProfileSeriesFeature'
664        elif tag==CSML('RaggedProfileSeriesFeature'):
665            return 'RaggedProfileSeriesFeature'
666        elif tag==CSML('RaggedSectionFeature'):
667            return 'RaggedSectionFeature'
668        elif tag==CSML('SectionFeature'):
669            return 'SectionFeature'
670        elif tag==CSML('ScanningRadarFeature'):
671            return 'ScanningRadarFeature'
672        elif tag==CSML('AlternatePointFeature'):
673            return 'AlternatePointFeature'
674        else: return 'AbstractFeature'
675    def _getReverseSubsType(self, typename):
676        if typename== 'GridFeature':
677            return CSML('GridFeature')
678        elif typename == 'GridSeriesFeature':
679            return CSML('GridSeriesFeature')
680        elif typename == 'PointSeriesFeature':
681            return CSML('PointSeriesFeature')
682        elif typename == 'ProfileFeature':
683            return CSML('ProfileFeature')
684        elif typename == 'ProfileSeriesFeature':
685            return CSML('ProfileSeriesFeature')
686        elif typename == 'SectionFeature':
687            return CSML('SectionFeature')
688        elif typename == 'ScanningRadarFeature':
689            return CSML('ScanningRadarFeature')
690        elif typename == 'RaggedSectionFeature':
691            return CSML('RaggedSectionFeature')
692        elif typename == 'RaggedProfileSeriesFeature':
693            return CSML('RaggedProfileSeriesFeature')
694        elif typename == 'PointFeature':
695            return CSML('PointFeature')
696        elif typename == 'TrajectoryFeature':
697            return CSML('TrajectoryFeature')
698        elif typename == 'AlternatePointFeature':
699            return CSML('AlternatePointFeature')
700        else: return CSML('AbstractFeature')
701
702       
703class Dataset(AbstractGML, csElement):   
704    ''' Dataset class, needed as root of tree'''
705    def __init__(self, **kwargs):
706        AbstractGML.__init__(self,**kwargs)
707        children = {'featureCollection':[GML('FeatureCollection') ,'FeatureCollection'],'fileExtracts':[FILEFORMATS, 'ArrayDescriptor']}
708        addchildren(self,children)
709    def toXML(self):
710        csmlfrag=ET.Element(CSML('Dataset'))
711        csElement.toXML(self, csmlfrag)
712        return csmlfrag
713    def _getSubstitutionType(self,tag):
714        if tag==CSML('NetCDFExtract'):
715            return 'NetCDFExtract'
716        elif tag==CSML('NASAAmesExtract'):
717            return 'NASAAmesExtract'
718        else: return 'ArrayDescriptor'
719    def _getReverseSubsType(self, typename):
720        if typename== 'NetCDFExtract':
721            return CSML('NetCDFExtract')
722        elif typename == 'NASAAmesExtract':
723            return CSML('NASAAmesExtract')
724        else: return CSML('ArrayDescriptor')
725       
726        return typename
727
728   
729def main():
730    '''round trip for testing purposes:'''
731    print '\n'
732    tree=ET.ElementTree(file='test.xml')
733    ds=Dataset()
734    ds.fromXML(tree.getroot())
735    csmltree=ds.toXML()
736    #print csmltree
737   
738    csmlout=parser_extra.PrettyPrint(csmltree)
739    csmlout=parser_extra.removeInlineNS(csmlout)
740    print '\n %s'% csmlout
741    #for member in ds.featureCollection.members:
742      #print dir(member.value)
743       
744
745if __name__=='__main__':
746    main()
Note: See TracBrowser for help on using the repository browser.