source: TI02-CSML/trunk/csml/parser.py @ 2385

Subversion URL: http://proj.badc.rl.ac.uk/svn/ndg/TI02-CSML/trunk/csml/parser.py@2385
Revision 2385, 48.4 KB checked in by domlowe, 13 years ago (diff)

various fixes to subsetting output

Line 
1import cElementTree as ET
2import elementtree.ElementTree as etree
3import sys, traceback
4import csml
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
18
19def myQName(uri,tag):
20    return "{"+uri+"}"+tag
21
22def CSML(tag):
23    return myQName(nsCSML,tag)
24
25def GML(tag):
26    return myQName(nsGML,tag)
27
28def SWE(tag):
29    return myQName(nsSWE,tag)
30
31def XLINK(tag):
32    return myQName(nsXLINK,tag)
33
34def addchildren(obj, dict):
35    ''' merges (adds) dictionary to existing self.CHILDREN dictionary '''
36    dict1 = dict
37    if hasattr(obj, 'CHILDREN'):
38      dict2=obj.CHILDREN
39    else:
40      dict2={}
41    dict3={}
42    for item in dict1:
43        dict3[item] =dict1[item]
44    for item in dict2:
45        dict3[item] =dict2[item]
46    obj.CHILDREN=dict3
47   
48
49def addatts(obj, atts):
50  ''' merges self.ATTRIBUTES  of inherited classes'''
51  if hasattr(obj, 'ATTRIBUTES'):
52    for att in atts:
53        obj.ATTRIBUTES.append(att)
54  else:
55    obj.ATTRIBUTES=atts
56
57def addelems(obj, elems):
58  ''' merges self.elems of inherited classes'''
59  if hasattr(obj, 'ELEMORDER'):
60    for elem in elems:
61        obj.ELEMORDER.append(elem)
62  else:
63    obj.ELEMORDER=elems
64
65
66#Some variable definitions: these things are often repeated so store in variables.
67FILEFORMATS=[CSML('NetCDFExtract'),CSML('NASAAmesExtract'), CSML('GRIBExtract'),CSML('CDMLExtract'), CSML('RawFileExtract'), CSML('AggregatedArray')]
68
69
70class csElement(object):
71    ''' main csElement class - all other elements inherit from this baseclass 
72    all the from/to XML conversion is done by this class'''
73   
74    def __init__(self, **kwargs):
75        for kw in kwargs:
76            self.__setattr__(kw, kwargs[kw])
77        if not hasattr(self, 'ATTRIBUTES'):
78            self.__dict__['ATTRIBUTES']=[]
79        if not hasattr(self, 'ELEMORDER'):
80            self.__dict__['ELEMORDER']=[]       
81        if not hasattr(self, 'CHILDREN'):
82            self.__dict__['CHILDREN']={}
83    #The __setattr__ and __getattribute__ special methods have been overridden.
84    #This is so that attributes can be called by their fully qualified name internally
85    #while being referenced by their short name externally.
86    # so 'id' and {'http://www.opengis.net/gml'}id always have the same value
87    #you can set either of them at any time and the other will be kept in sync.
88       
89    def __setattr__(self, name, value):
90        if hasattr(self, CSML(name)):
91            object.__setattr__(self, CSML(name), value)
92            object.__setattr__(self, name, value)
93        elif hasattr(self,GML(name)):
94            object.__setattr__(self, GML(name), value)
95            object.__setattr__(self, name, value)
96        elif hasattr(self,XLINK(name)):
97            object.__setattr__(self, XLINK(name), value)
98            object.__setattr__(self, name, value)
99        else:
100            if hasattr(self, 'ATTRIBUTES'):
101                if CSML(name) in self.__dict__['ATTRIBUTES']:
102                    object.__setattr__(self, CSML(name), value)
103                    object.__setattr__(self, name, value)
104                elif GML(name) in self.__dict__['ATTRIBUTES']:
105                    object.__setattr__(self, GML(name), value)
106                    object.__setattr__(self, name, value)
107                elif XLINK(name) in self.__dict__['ATTRIBUTES']:
108                    object.__setattr__(self, XLINK(name), value)
109                    object.__setattr__(self, name, value)
110                elif name in self.__dict__['ATTRIBUTES']:
111                    object.__setattr__(self, name, value)
112                    try:
113                        name=name.split('}')[1]
114                    except IndexError:
115                        pass
116                    object.__setattr__(self, name, value)
117                else:
118                    object.__setattr__(self, name, value)
119            else:
120                    object.__setattr__(self, name, value)
121   
122    def __getattribute__(self, name):
123            if CSML(name) in object.__dict__:
124                return object.__getattribute__(self,CSML(name))
125            elif GML(name) in object.__dict__:
126                return object.__getattribute__(self,GML(name))
127            elif XLINK(name) in object.__dict__:
128                return object.__getattribute__(self,XLINK(name))
129            else:
130                return object.__getattribute__(self,name) 
131       
132    def __removeURI(self, qname):
133        try:
134            attname = qname.split('}')[1]
135        except IndexError:
136            attname = qname
137        return attname
138       
139    def _getSubstitutionType(self,tag):
140        return tag.split('}')[1]
141       
142   
143    def _getReverseSubsType(self, typename):
144        return typename
145   
146    def addChildElem(self, childname, childobj):
147        #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.
148        if hasattr(self, childname):
149            currentattribute=getattr(self,childname)
150            if type(getattr(self,childname)) is list:
151                currentattribute.append(childobj)
152            else:
153                newlist=[currentattribute]
154                newlist.append(childobj)
155                setattr(self,childname, newlist)
156        else:
157            setattr(self,childname, childobj)
158
159    def toXML(self, csmlfrag, **kwargs):
160        #process self and convert to XML     
161        if hasattr(self, 'CONTENT'):
162            if self.CONTENT is not None: csmlfrag.text=self.CONTENT
163        if hasattr(self, 'ATTRIBUTES'):
164            for item in self.__dict__:
165                if item in self.ATTRIBUTES:                   
166                    csmlfrag.set(item, self.__dict__[item])
167    # self.CHILDREN (recursive - calls the toXML method of children
168        for child in self.ELEMORDER:
169            if not self.__dict__.has_key(child):
170                continue
171            appendLater=False
172            parserobjects=[]
173            if type(self.__dict__[child]) is list:
174                for a in self.__dict__[child]:
175                    parserobjects.append(a)
176            else:
177                parserobjects.append(self.__dict__[child])
178            parentfrag=None
179            if len(self.CHILDREN[child])>=3:
180                    ename2=self.CHILDREN[child][2]
181                    parentfrag=ET.Element(ename2)
182            for po in parserobjects:
183                if type(self.CHILDREN[child][0]) is not list:
184                    ename=self.CHILDREN[child][0]
185                else:
186                    ename = self._getReverseSubsType(type(po).__name__)
187                if len(self.CHILDREN[child])==3:
188                    frag=ET.Element(ename)
189                    po.toXML(frag)
190                    parentfrag.append(frag)
191                    appendLater=True
192                elif len(self.CHILDREN[child])>=4:
193                    if self.CHILDREN[child][3]==1:
194                        frag=ET.Element(ename)
195                        po.toXML(frag)
196                        parentfrag.append(frag)
197                        csmlfrag.append(parentfrag)
198                        parentfrag=ET.Element(parentfrag.tag)
199                        appendLater=False
200                else:
201                    frag=ET.Element(ename)
202                    try:
203                        po.toXML(frag)
204                    except:
205                        print 'PARSING ERROR - could not convert %s to XML'%frag
206                        print dir(ename)
207                        raise
208                    csmlfrag.append(frag)
209                    appendLater=True
210
211                if appendLater==True and parentfrag != None:             
212                    csmlfrag.append(parentfrag)   
213
214        return csmlfrag
215       
216    def fromXML(self,csmlfrag):
217        # deal with attributes, e.g. gml id's
218        if csmlfrag.text is not None:
219                self.CONTENT = csmlfrag.text
220        for item in csmlfrag.items():
221            if item[0] in self.ATTRIBUTES:
222                setattr(self, item[0], item[1])
223        #self.CHILDREN (recursive - calls the fromXML method of children
224        for frag in csmlfrag[:]:
225            #for each child element
226            #iterate through expected CHILDREN to find match
227            for child in self.CHILDREN:
228                if len(self.CHILDREN[child])>=3:
229                    ename = self.CHILDREN[child][2]
230                    ename2 = self.CHILDREN[child][0]
231                else:
232                    ename = self.CHILDREN[child][0] 
233                    ename2=None
234                #if there are options, then find the name that matches the frag
235                if ename2 is not None:
236                    if frag[:] != []:
237                        for subfrag in frag[:]:
238                            etype=None
239                            if type(ename2) is list:
240                                if subfrag.tag in ename2:
241                                    etype=self._getSubstitutionType(subfrag.tag)
242                            if subfrag.tag==ename2:
243                                etype=self.CHILDREN[child][1]
244                            if etype:
245                                childobj=eval(etype)()
246                                if len(self.CHILDREN[child])>=3:
247                                    if frag[:] != []:
248                                        childobj.fromXML(subfrag)
249                                else:
250                                    childobj.fromXML(frag)
251                                #set this object to be an attribute of the 'parent' (self) object
252                                if hasattr(self, child):
253                                    if type(self.__dict__[child]) is not list:
254                                        tmp=self.__dict__[child]
255                                        setattr(self, child, [tmp]) #convert to list
256                                    self.__dict__[child].append(childobj)
257                                else:
258                                    setattr(self, child, childobj)
259                else:
260                    etype=None
261                    if type(ename) is list:
262                        if frag.tag in ename:
263                            etype=self._getSubstitutionType(frag.tag)
264                    elif frag.tag==ename:
265                        etype=self.CHILDREN[child][1]
266                    if etype:
267                        childobj=eval(etype)()
268                        if len(self.CHILDREN[child])>=3:
269                            if frag[:] != []:
270                                childobj.fromXML(frag[0])
271                        else:
272                            childobj.fromXML(frag)
273                           
274                        #set this object to be an attribute of the 'parent' (self) object
275                        if hasattr(self, child):
276                            if type(self.__dict__[child]) is not list:
277                                tmp=self.__dict__[child]
278                                setattr(self, child, [tmp]) #convert to list
279                            self.__dict__[child].append(childobj)
280                        else:
281                            setattr(self, child, childobj)
282
283               
284   
285class AbstractGML(csElement):
286    def __init__(self, **kwargs):
287        a=[GML('id'), GML('name')]
288        addatts(self,a)
289        elems=['metaDataProperty', 'description']
290        addelems(self,elems)
291        children={elems[0]:[GML('metaDataProperty'),'csString'],elems[1]:[GML('description'),'csString']}
292        addchildren(self,children)
293        csElement.__init__(self,**kwargs)
294       
295class AssociationAttributeGroup(csElement):
296    def __init__(self, **kwargs):
297        a =[XLINK('href'),XLINK('role'), XLINK('arcrole'),XLINK('title'), XLINK('show'), XLINK('actuate')] 
298        addatts(self,a)
299        csElement.__init__(self,**kwargs)
300       
301class csString(AssociationAttributeGroup, csElement):
302    def __init__(self, text=None,**kwargs):
303        #Needed so it can use xlink
304        addelems(self,[])
305        AssociationAttributeGroup.__init__(self,**kwargs)
306        if text != None:
307            if type(text) is not str:
308                text=str(text)
309            self.CONTENT=text
310        children={}
311        addchildren(self,children)
312        csElement.__init__(self,**kwargs)
313       
314class SRSReferenceGroup(csElement):
315    def __init__(self, **kwargs):
316        a =['srsName','srsDimension'] 
317        addatts(self,a)
318        csElement.__init__(self,**kwargs)
319               
320class SRSInformationGroup(csElement):
321    def __init__(self, **kwargs):
322        a =['uomLabels','axisLabels']
323        addatts(self,a)
324        csElement.__init__(self,**kwargs)
325       
326class ArrayDescriptor(csElement):
327    def __init__(self,**kwargs):
328        a=['id']
329        addatts(self,a)
330        elems=['arraySize', 'uom', 'numericType','regExpTransform','numericTransform']
331        addelems(self,elems)
332        children={elems[0]:[CSML('arraySize'), 'csString'], elems[1]:[CSML('uom'),'csString'], elems[2]:[CSML('numericType'),'csString'], elems[3]:[CSML('regExpTransform'),'csString'], elems[4]:[CSML('numericTransform'),'csString']}
333        addchildren(self,children)
334        csElement.__init__(self,**kwargs)
335               
336class GridEnvelope(AbstractGML,SRSReferenceGroup, csElement):
337    def __init__(self, **kwargs):
338        SRSReferenceGroup.__init__(self,**kwargs)
339        AbstractGML.__init__(self,**kwargs)
340        elems=['low', 'high']
341        addelems(self,elems)
342        children={elems[0]:[GML('low'), 'csString'],elems[1]:[GML('high'), 'csString']}
343        addchildren(self,children)
344        csElement.__init__(self,**kwargs)
345       
346class Envelope(AbstractGML,SRSReferenceGroup, csElement):
347    def __init__(self, **kwargs):
348        SRSReferenceGroup.__init__(self,**kwargs)
349        AbstractGML.__init__(self,**kwargs)
350        elems=['lowerCorner','upperCorner']
351        addelems(self,elems)
352        children={elems[0]:[GML('lowerCorner'), 'csString'],elems[1]:[GML('upperCorner'), 'csString']}
353        addchildren(self,children)
354        csElement.__init__(self,**kwargs)
355       
356class EnvelopeWithTimePeriod(Envelope):
357    def __init__(self, **kwargs):
358        Envelope.__init__(self,**kwargs)
359        elems=['beginPosition', 'endPosition']
360        addelems(self,elems)
361        children={elems[0]:[GML('beginPosition'), 'csString'], elems[1]:[GML('endPosition'), 'csString']}
362        addchildren(self,children)
363        csElement.__init__(self,**kwargs)
364
365class AbstractFeature(AbstractGML,csElement):
366    def __init__(self, **kwargs):
367        AbstractGML.__init__(self,**kwargs)
368        elems=['boundedBy']
369        addelems(self,elems)
370        #this pattern works but can only accept EnvelopeWithTimePeriod for the boundedBy,
371        #which is probably ok   
372        children={elems[0]:[GML('EnvelopeWithTimePeriod'), 'EnvelopeWithTimePeriod', GML('boundedBy')]}
373        addchildren(self,children)
374        csElement.__init__(self,**kwargs)
375       
376class AbstractFeatureCollection(AbstractFeature,csElement):
377    def __init__(self, **kwargs):
378        AbstractFeature.__init__(self,**kwargs)
379        csElement.__init__(self,**kwargs)
380       
381class DomainSet(AbstractGML,AssociationAttributeGroup,csElement):
382    def __init__(self, **kwargs):
383        AbstractGML.__init__(self,**kwargs)
384        addchildren(self,{})
385        csElement.__init__(self,**kwargs)
386       
387class AggregatedArray(ArrayDescriptor,csElement):
388    def __init__(self, **kwargs):
389        ArrayDescriptor.__init__(self,**kwargs)
390        elems=['aggType', 'aggIndex', 'components']
391        addelems(self,elems)
392        children={elems[0]:[CSML('aggType'),'csString'], elems[1]:[CSML('aggIndex'),'csString'],elems[2]:[FILEFORMATS, 'ArrayDescriptor',CSML('component')]}
393        addchildren(self,children)
394        csElement.__init__(self,**kwargs)
395#'component':[CSML:('component'), 'ArrayDescriptor', CSML('component')],
396class MeasureOrNullList(AbstractGML,csElement):
397    def __init__(self, **kwargs):
398        AbstractGML.__init__(self,**kwargs)
399        elems=['__insertedExtract']  # should this be here ? check
400        addelems(self,elems)
401        #note __insertedExtract is used in resolving xlinks and shouldn't be written to directly (except by the code which handles the xlink resolutions)
402        children={elems[0]:[FILEFORMATS,'FileExtract',CSML('__insertedExtract')]}
403        addchildren(self,children)
404        a =['uom'] 
405        addatts(self,a)
406        csElement.__init__(self,**kwargs)
407       
408       
409class CompositeValue(AbstractGML,csElement):
410    def __init__(self, **kwargs):
411        AbstractGML.__init__(self,**kwargs)
412        elems=['measures']
413        addelems(self,elems)
414        children={elems[0]:[GML('measure'),'csString',GML('valueComponents')]}
415        addchildren(self,children)
416        csElement.__init__(self,**kwargs)
417       
418class DataBlock(AbstractGML,csElement):
419    #THIS IS INCOMPLETE
420    def __init__(self, **kwargs):
421        AbstractGML.__init__(self,**kwargs)
422        elems=['doubleOrNullTupleList','rangeParameters']
423        addelems(self,elems)
424        children={elems[0]:[GML('doubleOrNullTupleList'),'csString'],elems[1]:[GML('CompositeValue'), 'CompositeValue', GML('rangeParameters')]}
425        addchildren(self,children)
426        csElement.__init__(self,**kwargs)
427
428class ValueComponent(AbstractGML, AssociationAttributeGroup, csElement):
429    def __init__(self, **kwargs):
430        AbstractGML.__init__(self,**kwargs)
431        AssociationAttributeGroup.__init__(self,**kwargs)
432        elems=['quantityList']
433        addelems(self,elems)
434        children=children={elems[0]:[GML('QuantityList'), 'MeasureOrNullList']}
435        addchildren(self,children)
436        csElement.__init__(self,**kwargs)
437
438class ValueArray(AbstractGML, csElement):
439    def __init__(self, **kwargs):
440        AbstractGML.__init__(self,**kwargs)
441        elems=['valueComponent']
442        addelems(self,elems)
443        #this is a bit of a diversion from the object/property pattern but is necessary to
444        #make valueComponent a class so valueComponent can have xlink attributes
445        children=children={elems[0]:[GML('valueComponent'), 'ValueComponent', ]}
446        addchildren(self,children)
447        csElement.__init__(self,**kwargs)
448       
449
450class RangeSet(AbstractGML,AssociationAttributeGroup,csElement):
451    def __init__(self, **kwargs):
452        AbstractGML.__init__(self,**kwargs)
453        AssociationAttributeGroup.__init__(self,**kwargs)
454        elems=['quantityList', 'dataBlock', 'arrayDescriptor', 'valueArray']
455        addelems(self,elems)
456        children={elems[0]:[GML('QuantityList'), 'MeasureOrNullList'],        elems[1]:[GML('DataBlock'),'DataBlock'],elems[2]:[FILEFORMATS, 'ArrayDescriptor'],  elems[3]:[CSML('AggregatedArray'), 'AggregatedArray'],
457        elems[3]:[GML('ValueArray'),'ValueArray']}
458        addchildren(self,children)
459        csElement.__init__(self,**kwargs)
460       
461class MultiPoint(AbstractGML, SRSReferenceGroup,csElement):
462    def __init__(self, **kwargs):
463        AbstractGML.__init__(self,**kwargs)
464        SRSReferenceGroup.__init__(self,**kwargs)
465        elems=['pointMember','pointMembers']
466        addelems(self,elems)
467        children={elems[0]:[GML('pointMember'), 'csString'],elems[0]:[GML('pointMember'), 'csString']}
468        addchildren(self,children)
469        csElement.__init__(self,**kwargs)
470       
471class Point(AbstractGML,SRSReferenceGroup,csElement):
472    def __init__(self, **kwargs):
473        AbstractGML.__init__(self,**kwargs)
474        SRSReferenceGroup.__init__(self,**kwargs)
475        elems=['pos','coordinates']
476        addelems(self,elems)
477        children={elems[0]:[GML('pos'), 'csString'],elems[1]:[GML('coordinates'), 'csString']}
478        addchildren(self,children)
479        csElement.__init__(self,**kwargs)
480       
481class PointDomain(DomainSet, MultiPoint,csElement):
482    def __init__(self, **kwargs):
483        DomainSet.__init__(self,**kwargs)
484        MultiPoint.__init__(self,**kwargs)
485        children={}
486        addchildren(self,children)
487        csElement.__init__(self,**kwargs)
488       
489class ProfileDomain(DomainSet, MultiPoint,csElement):
490    def __init__(self, **kwargs):
491        DomainSet.__init__(self,**kwargs)
492        MultiPoint.__init__(self,**kwargs)
493        children={}
494        addchildren(self,children)
495        csElement.__init__(self,**kwargs)
496
497
498class AbstractCoverage(AbstractFeature, csElement):
499    def __init__(self, **kwargs):
500        AbstractFeature.__init__(self,**kwargs)
501        csElement.__init__(self,**kwargs)
502       
503class AbstractDiscreteCoverage(AbstractCoverage, csElement):
504    def __init__(self, **kwargs):
505        AbstractCoverage.__init__(self,**kwargs)
506        addchildren(self,{})
507        csElement.__init__(self,**kwargs)
508       
509class Definition(AbstractGML):
510    def __init__(self, **kwargs):
511        AbstractGML.__init__(self,**kwargs)
512        addchildren(self,{})
513        csElement.__init__(self,**kwargs)
514       
515class Phenomenon(Definition,AssociationAttributeGroup):
516    def __init__(self, **kwargs):
517        Definition.__init__(self,**kwargs)
518        AssociationAttributeGroup.__init__(self,**kwargs)
519        children = {'':[CSML(''), '']}   
520        addchildren(self,children)
521        csElement.__init__(self,**kwargs)
522               
523class SpatialOrTemporalPositionList(AssociationAttributeGroup, AbstractGML,  csElement):
524    def __init__(self, **kwargs):
525        AbstractGML.__init__(self,**kwargs)
526        AssociationAttributeGroup.__init__(self,**kwargs)
527        elems=['coordinateList', 'timePositionList','__insertedExtract']
528        addelems(self,elems)
529        children={elems[0]:[CSML('coordinateList'),'csString'], elems[1]:[CSML('timePositionList'),'TimePositionList'],elems[2]:[FILEFORMATS,'FileExtract',CSML('__insertedExtract')]}
530        addchildren(self,children)
531        csElement.__init__(self,**kwargs)
532   
533    def toXML(self,csmlfrag,**kwargs):
534        csmlfrag=csElement.toXML(self,csmlfrag, **kwargs)
535        #This is mandatory even if empty when using xlink       
536        if not hasattr(self, 'timePositionList'):
537            if not hasattr(self, 'coordinateList'):
538                 if csmlfrag.get(XLINK('arcrole')) is not None:
539                    if csmlfrag.get(XLINK('arcrole')).split('#')[1] == 'timePositionList':
540                        ET.SubElement(csmlfrag, CSML('timePositionList'))
541                    elif csmlfrag.get(XLINK('arcrole')).split('#')[1] =='coordinateList':
542                        ET.SubElement(csmlfrag, CSML('coordinateList'))                       
543        return csmlfrag
544
545class GridOrdinateDescription(AbstractGML,csElement):
546    def __init__(self, **kwargs):
547        AbstractGML.__init__(self,**kwargs)
548        elems=['coordAxisLabel', 'coordAxisValues', 'gridAxesSpanned', 'sequenceRule']
549        addelems(self,elems)
550        children={elems[0]:[CSML('coordAxisLabel'), 'csString'], elems[1]:[CSML('SpatialOrTemporalPositionList'),'SpatialOrTemporalPositionList',CSML('coordAxisValues')], elems[2]:[CSML('gridAxesSpanned'), 'csString'], elems[3]:[CSML('sequenceRule'),'SequenceRule']}
551        addchildren(self,children)
552        csElement.__init__(self,**kwargs)
553    def toXML(self, csmlfrag, **kwargs):
554        csmlfrag=AbstractGML.toXML(self, csmlfrag,**kwargs)
555        #promote XLinks up from SpatialOrTemporalPositionList       
556        #this all done at the elementtree level
557       
558        for frag in csmlfrag:
559            if frag.tag ==CSML('coordAxisValues'):
560                try:       
561                    frag.set(XLINK('href'),self.coordAxisValues.href)                               
562                    for subfrag in frag:   
563                        del subfrag.attrib[XLINK('href')]                                                             
564                except:
565                    pass
566                try:       
567                    frag.set(XLINK('show'),self.coordAxisValues.show)                               
568                    for subfrag in frag:   
569                        del subfrag.attrib[XLINK('show')]                                                             
570                except:
571                    pass
572                try:       
573                    frag.set(XLINK('role'),self.coordAxisValues.role)                               
574                    for subfrag in frag:   
575                        del subfrag.attrib[XLINK('role')]                                                             
576                except:
577                    pass
578                try:       
579                    frag.set(XLINK('arcrole'),self.coordAxisValues.arcrole)                               
580                    for subfrag in frag:   
581                        del subfrag.attrib[XLINK('arcrole')]                                                             
582                except:
583                    pass
584             
585
586        return csmlfrag
587   
588    def fromXML(self, csmlfrag):
589        #promote xlinks up a level to the coordAxisValues property element
590        for frag in csmlfrag:
591            if frag.tag == CSML('coordAxisValues'):             
592                for att in ['href', 'show', 'role', 'arcrole']:
593                    try: 
594                        for subfrag in frag[:]:
595                            subfrag.set(XLINK(att),frag.attrib[XLINK(att)])     
596                    except:
597                        pass
598               
599        csElement.fromXML(self, csmlfrag)
600
601           
602       
603class SequenceRule(csElement):
604    def __init__(self, **kwargs):
605        a=['axisOrder']
606        addatts(self,a)
607        children={}
608        addchildren(self,children)
609        csElement.__init__(self,**kwargs)
610       
611class GridPointDescription(AbstractGML,csElement):
612    def __init__(self, **kwargs):
613        AbstractGML.__init__(self,**kwargs)
614        elems=['posList', 'sequenceRule']
615        addelems(self,elems)
616        children={elems[0]:[CSML('posList'),'csString'],elems[1]:[CSML('sequenceRule'),'SequenceRule']}
617        addchildren(self,children)
618        csElement.__init__(self,**kwargs)
619
620class TimePositionList(AbstractGML,csString,csElement):
621    def __init__(self, **kwargs):
622        AbstractGML.__init__(self,**kwargs)
623        csString.__init__(self, **kwargs)
624        elems=[]
625        addelems(self,elems)
626        a=['frame', 'calendarEraName','indeterminatePosition']
627        addatts(self,a)
628        addchildren(self,{})
629        csElement.__init__(self,**kwargs)
630
631class GridCoordinatesTable(AbstractGML,csElement):
632    def __init__(self,**kwargs):
633        '''the additional value '1' in the children dictionary is used to signify that the elements must be nested as:
634        <gml:ordinate>
635            <gml:GridOrdinateDescription>
636        </gml:ordinate>
637        <gml:ordinate>
638            <gml:GridOrdinateDescription>
639        </gml:ordinate>
640       
641        not as:
642        <gml:ordinate>
643            <gml:GridOrdinateDescription>
644            <gml:GridOrdinateDescription>
645        </gml:ordinate> '''
646        AbstractGML.__init__(self,**kwargs)
647        elems=['gridOrdinates' , 'gridPoints']
648        addelems(self,elems)
649        children={elems[0]:[CSML('GridOrdinateDescription'), 'GridOrdinateDescription',CSML('gridOrdinate'),1], elems[1]:[CSML('GridPointDescription'),'GridPointDescription',CSML('gridPoints')]}
650        addchildren(self,children)
651        csElement.__init__(self,**kwargs)
652       
653class Grid(AbstractGML, AssociationAttributeGroup, SRSInformationGroup, SRSReferenceGroup, csElement):
654    def __init__(self, **kwargs):
655        AbstractGML.__init__(self,**kwargs)
656        AssociationAttributeGroup.__init__(self,**kwargs)
657        SRSReferenceGroup.__init__(self,**kwargs)
658        SRSInformationGroup.__init__(self,**kwargs)
659        a=['dimension']
660        addatts(self,a)
661        elems=['limits', 'aLabels','axisName']
662        addelems(self, elems)
663        children = {elems[1]:[CSML('axisLabels'),'csString'],elems[2]:[CSML('axisName'),'csString'], elems[0]:[GML('GridEnvelope'),'GridEnvelope',CSML('limits')]}
664        addchildren(self,children)
665        csElement.__init__(self,**kwargs)
666           
667class ReferenceableGrid(Grid, csElement):
668    def __init__(self, **kwargs):
669        Grid.__init__(self,**kwargs)
670        elems=['coordTransformTable']
671        addelems(self,elems)
672        children={elems[0]:[CSML('GridCoordinatesTable'), 'GridCoordinatesTable', CSML('coordTransformTable')]}
673        addchildren(self,children)
674        csElement.__init__(self,**kwargs)
675
676class ReferenceableGridCoverage(AbstractDiscreteCoverage, csElement):
677    def __init__(self, **kwargs):
678        AbstractDiscreteCoverage.__init__(self,**kwargs)
679        elems=[referenceableGridDomain]
680        addelems(self,elems)
681        children={elems[0]:[CSML('ReferenceableGrid'),'ReferenceableGrid' ,CSML('referenceableGridDomain') ]}
682        addchildren(self,children)
683        csElement.__init__(self,**kwargs)
684       
685class AlternatePointCoverage(AbstractDiscreteCoverage, csElement):
686    def __init__(self, **kwargs):
687        AbstractDiscreteCoverage.__init__(self,**kwargs)
688        elems=['alternatePointDomain','rangeSet','coverageFunction']
689        addelems(self,elems)
690        children={elems[0]:[GML('Point'),'Point', CSML('alternatePointDomain')], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
691        addchildren(self,children)
692        csElement.__init__(self,**kwargs)
693
694class ProfileCoverage(AbstractDiscreteCoverage, csElement):
695    def __init__(self, **kwargs):
696        AbstractDiscreteCoverage.__init__(self,**kwargs)
697        elems=['profileDomain', 'rangeSet' ,'coverageFunction']
698        addelems(self,elems)
699        children={elems[0]:[CSML('ProfileDomain'),'ProfileDomain' ,CSML('profileDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
700        addchildren(self,children)
701        csElement.__init__(self,**kwargs)
702       
703class PointCoverage(AbstractDiscreteCoverage, csElement):
704    def __init__(self, **kwargs):
705        AbstractDiscreteCoverage.__init__(self,**kwargs)
706        elems=['pointDomain','rangeSet', 'coverageFunction']
707        addelems(self,elems)
708        children={elems[0]:[CSML('PointDomain'),'PointDomain' ,CSML('pointDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
709        addchildren(self,children)
710        csElement.__init__(self,**kwargs)
711       
712class TimeSeries(AbstractGML, csElement):
713    def __init__(self, **kwargs):
714        AbstractGML.__init__(self,**kwargs)
715        elems=['timePositionList']
716        addelems(self,elems)
717        children={elems[0]:[CSML('timePositionList'), 'csString']}
718        addchildren(self,children)
719        csElement.__init__(self,**kwargs)
720
721class PointSeriesCoverage(AbstractDiscreteCoverage, csElement):
722    def __init__(self, **kwargs):
723        AbstractDiscreteCoverage.__init__(self,**kwargs)
724        elems=['pointSeriesDomain','rangeSet','coverageFunction']
725        addelems(self,elems)
726        children={elems[0]:[CSML('TimeSeries'),'TimeSeries' ,CSML('pointSeriesDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
727        addchildren(self,children)
728        csElement.__init__(self,**kwargs)
729       
730class ProfileSeriesDomain(ReferenceableGrid, DomainSet, csElement):
731    def __init__(self, **kwargs):
732        DomainSet.__init__(self,**kwargs)
733        ReferenceableGrid.__init__(self,**kwargs)
734        children={}
735        addchildren(self,children)
736        csElement.__init__(self,**kwargs)
737       
738class ProfileSeriesCoverage(AbstractDiscreteCoverage,csElement):
739    def __init__(self, **kwargs):
740        AbstractDiscreteCoverage.__init__(self,**kwargs)
741        elems=['profileSeriesDomain', 'rangeSet', 'coverageFunction']
742        addelems(self,elems)
743        children={elems[0]:[CSML('ProfileSeriesDomain'),'ProfileSeriesDomain' ,CSML('profileSeriesDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
744        addchildren(self,children)
745        csElement.__init__(self,**kwargs)
746       
747class SectionDomain(ReferenceableGrid, DomainSet, csElement):
748    def __init__(self, **kwargs):
749        DomainSet.__init__(self,**kwargs)
750        ReferenceableGrid.__init__(self,**kwargs)
751        children={}
752        addchildren(self,children)
753        csElement.__init__(self,**kwargs)
754       
755class SectionCoverage(AbstractDiscreteCoverage,csElement):
756    def __init__(self, **kwargs):
757        AbstractDiscreteCoverage.__init__(self,**kwargs)
758        elems=['sectionDomain', 'rangeSet' , 'coverageFunction']
759        addelems(self,elems)
760        children={elems[0]:[CSML('SectionDomain'),'SectionDomain' ,CSML('sectionDomain') ],elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
761        addchildren(self,children)
762        csElement.__init__(self,**kwargs)
763       
764class TrajectoryDomain(ReferenceableGrid, DomainSet, csElement):
765    def __init__(self, **kwargs):
766        DomainSet.__init__(self,**kwargs)
767        ReferenceableGrid.__init__(self,**kwargs)
768        children={}
769        addchildren(self,children)
770        csElement.__init__(self,**kwargs)
771       
772class TrajectoryCoverage(AbstractDiscreteCoverage,csElement):
773    def __init__(self, **kwargs):
774        AbstractDiscreteCoverage.__init__(self,**kwargs)
775        elems=['trajectoryDomain', 'rangeSet', 'coverageFunction']
776        addelems(self,elems)
777        children={elems[0]:[CSML('TrajectoryDomain'),'TrajectoryDomain' ,CSML('trajectoryDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
778        addchildren(self,children)
779        csElement.__init__(self,**kwargs)
780
781class ScanningRadarDomain(ReferenceableGrid, DomainSet, csElement):
782    def __init__(self, **kwargs):
783        DomainSet.__init__(self,**kwargs)
784        ReferenceableGrid.__init__(self,**kwargs)
785        children={}
786        addchildren(self,children)
787        csElement.__init__(self,**kwargs)
788       
789class ScanningRadarCoverage(AbstractDiscreteCoverage,csElement):
790    def __init__(self, **kwargs):
791        AbstractDiscreteCoverage.__init__(self,**kwargs)
792        elems=['scanningRadarDomain', 'rangeSet','coverageFunction']
793        addelems(self,elems)
794        children={elems[0]:[CSML('ScanningRadarDomain'),'ScanningRadarDomain' ,CSML('scanningRadarDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
795        addchildren(self,children)
796        csElement.__init__(self,**kwargs)
797
798
799class GridSeriesDomain(ReferenceableGrid, csElement):
800    def __init__(self, **kwargs):
801        #DomainSet.__init__(self,**kwargs)
802        ReferenceableGrid.__init__(self,**kwargs)
803        children={}
804        addchildren(self,children)
805        csElement.__init__(self,**kwargs)
806
807class GridSeriesCoverage(AbstractDiscreteCoverage,csElement):
808    def __init__(self, **kwargs):
809        elems=['gridSeriesDomain', 'rangeSet', 'coverageFunction']
810        addelems(self,elems)
811        children={elems[0]:[CSML('GridSeriesDomain'),'GridSeriesDomain' ,CSML('gridSeriesDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
812        addchildren(self,children)
813        AbstractDiscreteCoverage.__init__(self,**kwargs)
814        csElement.__init__(self,**kwargs)
815
816class AlternatePointFeature(AbstractFeature, csElement):
817    def __init__(self, **kwargs):
818        AbstractFeature.__init__(self,**kwargs)
819        elems=['location', 'time', 'value','parameter']
820        addelems(self,elems)
821        children={elems[0]:[CSML('location'), 'csString'],elems[1]:[CSML('time'), 'csString'], elems[2]:[CSML('AlternatePointCoverage'), 'AlternatePointCoverage', CSML('value')],elems[3]:[CSML('parameter'), 'Phenomenon']}
822        addchildren(self,children)
823        csElement.__init__(self,**kwargs)
824
825class DirectPositionList(SRSReferenceGroup, csElement):
826    def __init__(self, **kwargs):
827        SRSReferenceGroup.__init__(self,**kwargs)
828        children=[]
829        addchildren(self,children)
830        csElement.__init__(self,**kwargs)
831       
832class PointFeature(AbstractFeature, csElement):
833    def __init__(self, **kwargs):
834        AbstractFeature.__init__(self,**kwargs)
835        elems=['location', 'time', 'value','parameter']
836        addelems(self,elems)
837        children={elems[0]:[CSML('location'), 'DirectPositionList'],elems[1]:[CSML('time'), 'csString'], elems[2]:[CSML('PointCoverage'), 'PointCoverage', CSML('value')], elems[3]:[CSML('parameter'), 'Phenomenon']}
838        addchildren(self,children)
839        csElement.__init__(self,**kwargs)
840
841class PointCollectionFeature(AbstractFeature, csElement):
842    def __init__(self, **kwargs):
843        AbstractFeature.__init__(self,**kwargs)
844        elems=['time', 'value', 'parameter']
845        addelems(self,elems)
846        children={elems[0]:[CSML('time'), 'csString'], elems[1]:[CSML('MultiPointCoverage'), 'MultiPointCoverage', CSML('value')], elems[2]:[CSML('parameter'), 'Phenomenon']}
847        addchildren(self,children)
848        csElement.__init__(self,**kwargs)
849
850
851class PointSeriesFeature(AbstractFeature, csElement):
852    def __init__(self, **kwargs):
853        AbstractFeature.__init__(self,**kwargs)
854        elems=['location','value','parameter']
855        addelems(self,elems)
856        children={elems[0]:[CSML('location'), 'csString'], elems[1]:[CSML('PointSeriesCoverage'), 'PointSeriesCoverage', CSML('value')], elems[2]:[CSML('parameter'), 'Phenomenon']}
857        addchildren(self,children)
858        csElement.__init__(self,**kwargs)
859
860
861class GridFeature(AbstractFeature, csElement):
862    def __init__(self, **kwargs):
863        AbstractFeature.__init__(self,**kwargs)
864        elems=['time', 'value', 'parameter']
865        addelems(self,elems)
866        children={elems[0]:[CSML('time'), 'csString'], elems[1]:[CSML('ReferenceableGridCoverage'), 'ReferenceableGridCoverage', CSML('value')], elems[2]:[CSML('parameter'), 'Phenomenon']}
867        addchildren(self,children)
868        csElement.__init__(self,**kwargs)
869
870class GridSeriesFeature(AbstractFeature, csElement):
871    def __init__(self, **kwargs):
872        AbstractFeature.__init__(self,**kwargs)
873        elems=['value','parameter']
874        addelems(self,elems)
875        children={elems[0]:[CSML('GridSeriesCoverage'), 'GridSeriesCoverage', CSML('value')],elems[1]:[CSML('parameter'), 'Phenomenon']}
876        addchildren(self,children)
877        csElement.__init__(self,**kwargs)
878
879class ProfileFeature(AbstractFeature, csElement):
880    def __init__(self, **kwargs):
881        AbstractFeature.__init__(self,**kwargs)
882        elems=['time', 'location', 'value', 'parameter']
883        addelems(self,elems)
884        children={elems[0]:[CSML('time'), 'csString'],elems[1]:[CSML('location'), 'csString'], elems[2]:[CSML('ProfileCoverage'), 'ProfileCoverage', CSML('value')], elems[3]:[CSML('parameter'), 'Phenomenon']}
885        addchildren(self,children)
886        csElement.__init__(self,**kwargs)
887
888class ProfileSeriesFeature(AbstractFeature, csElement):
889    def __init__(self, **kwargs):
890        AbstractFeature.__init__(self,**kwargs)
891        elems=['location', 'value', 'parameter']
892        addelems(self,elems)
893        children={elems[0]:[CSML('location'), 'csString'], elems[1]:[CSML('ProfileSeriesCoverage'), 'ProfileSeriesCoverage', CSML('value')], elems[2]:[CSML('parameter'), 'Phenomenon']}
894        addchildren(self,children)
895        csElement.__init__(self,**kwargs)
896
897class RaggedProfileSeriesFeature(AbstractFeature, csElement):
898    def __init__(self, **kwargs):
899        AbstractFeature.__init__(self,**kwargs)
900        elems=['location', 'profileLength', 'value', 'parameter']
901        addelems(self,elems)
902        children={elems[0]:[CSML('location'), 'csString'], elems[1]:[CSML('profileLength'), 'csString'],elems[2]:[CSML('ProfileSeriesCoverage'), 'ProfileSeriesCoverage', CSML('value')], elems[3]:[CSML('parameter'), 'Phenomenon']}
903        addchildren(self,children)
904        csElement.__init__(self,**kwargs)
905
906class RaggedSectionFeature(AbstractFeature, csElement):
907    def __init__(self, **kwargs):
908        AbstractFeature.__init__(self,**kwargs)
909        elems=['stationLocations', 'stationTimes', 'profileLength' 'value','parameter']
910        addelems(self,elems)
911        children={elems[0]:[CSML('stationLocations'), 'csString'], elems[1]:[CSML('stationTimes'), 'csString'],elems[2]:[CSML('profileLength'),'csString'],elems[3]:[CSML('SectionCoverage'), 'SectionCoverage', CSML('value')], elems[4]:[CSML('parameter'), 'Phenomenon']}
912        addchildren(self,children)
913        csElement.__init__(self,**kwargs)
914
915class SectionFeature(AbstractFeature, csElement):
916    def __init__(self, **kwargs):
917        AbstractFeature.__init__(self,**kwargs)
918        elems=['stationLocations', 'stationTimes','value', 'parameter']
919        addelems(self,elems)
920        children={elems[0]:[CSML('stationLocations'), 'csString'], elems[1]:[CSML('stationTimes'), 'TimePositionList'],elems[2]:[CSML('SectionCoverage'), 'SectionCoverage', CSML('value')], elems[3]:[CSML('parameter'), 'Phenomenon']}
921        addchildren(self,children)
922        csElement.__init__(self,**kwargs)
923
924class ScanningRadarFeature(AbstractFeature, csElement):
925    def __init__(self, **kwargs):
926        AbstractFeature.__init__(self,**kwargs)
927        elems=['elevation','value', 'parameter']
928        addelems(self,elems)
929        children={elems[0]:[CSML('elevation'), 'csString'], elems[1]:[CSML('ScanningRadarCoverage'), 'ScanningRadarCoverage', CSML('value')], elems[2]:[CSML('parameter'), 'Phenomenon']}
930        addchildren(self,children)
931        csElement.__init__(self,**kwargs)
932
933       
934class SwathFeature(AbstractFeature, csElement):
935    def __init__(self, **kwargs):
936        AbstractFeature.__init__(self,**kwargs)
937        elems=['eqCrossLon', 'eqCrossTime', 'value', 'parameter']
938        addelems(self,elems)
939        children={elems[0]:[CSML('eqCrossLon'), 'csString'],elems[1]:[CSML('eqCrossTime'), 'csString'], elems[2]:[CSML('ReferenceableGridCoverage'), 'ReferenceableGridCoverage', CSML('value')], elems[3]:[CSML('parameter'), 'Phenomenon']}
940        addchildren(self,children)
941        csElement.__init__(self,**kwargs)
942       
943class TrajectoryFeature(AbstractFeature, csElement):
944    def __init__(self, **kwargs):
945        AbstractFeature.__init__(self,**kwargs)
946        elems=['value', 'parameter']
947        addelems(self,elems)
948        children={elems[0]:[CSML('TrajectoryCoverage'), 'TrajectoryCoverage', CSML('value')], elems[1]:[CSML('parameter'), 'Phenomenon']}
949        addchildren(self,children)
950        csElement.__init__(self,**kwargs)
951       
952class FileList(AssociationAttributeGroup,csElement):
953    def __init__(self,**kwargs):
954        AssociationAttributeGroup.__init__(self,**kwargs)       
955        a=['id']
956        addatts(self,a)
957        elems=['fileNames']
958        addelems(self,elems)
959        children= {elems[0]:[CSML('fileNames'), 'csString']}
960        addchildren(self,children)
961        csElement.__init__(self,**kwargs)
962       
963class FileExtract(ArrayDescriptor, csElement):
964    def __init__(self,**kwargs):
965        ArrayDescriptor.__init__(self,**kwargs)
966        elems=['fileName', 'fileList', 'fileListXLINK']
967        addelems(self,elems)
968        children= {elems[0]:[CSML('fileName'), 'csString'],  elems[1]:[CSML('FileList'), 'FileList', CSML('fileList')],elems[2]:[CSML('fileList'), 'csString']}
969        addchildren(self,children)
970        csElement.__init__(self,**kwargs)
971   
972class NetCDFExtract(FileExtract, csElement):
973    def __init__(self,**kwargs):
974        FileExtract.__init__(self, **kwargs)
975        elems=['variableName']
976        addelems(self,elems)
977        children={elems[0]:[CSML('variableName'), 'csString']}
978        addchildren(self,children)
979        csElement.__init__(self,**kwargs)
980
981class NASAAmesExtract(FileExtract, csElement):
982    def __init__(self,**kwargs):
983        FileExtract.__init__(self, **kwargs)
984        elems=['variableName', 'index']
985        addelems(self,elems)
986        children={elems[0]:[CSML('variableName'), 'csString'],elems[1]:[CSML('index'),'csString']}
987        addchildren(self,children)
988        csElement.__init__(self,**kwargs)
989
990class CSMLStorageDescriptor(csElement):
991    def __init__(self,**kwargs):
992        addatts(self,[])
993        elems=['descriptors']
994        addelems(self,elems)
995        children={elems[0]:[[CSML('NetCDFExtract'),CSML('AggregatedArray')], 'FileExtract', CSML('descriptor'),1]}
996        addchildren(self,children)
997        csElement.__init__(self,**kwargs)
998
999class CSMLFeatureCollection(AbstractFeatureCollection,csElement,):
1000    def __init__(self,**kwargs):
1001        AbstractFeatureCollection.__init__(self,**kwargs)
1002        elems=['featureMembers']
1003        addelems(self,elems)
1004        children={elems[0]:[[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', CSML('featureMember'),1]}
1005        addchildren(self,children)
1006        csElement.__init__(self,**kwargs)
1007    def _getSubstitutionType(self,tag):
1008        if tag==CSML('GridFeature'):
1009            return 'GridFeature'
1010        elif tag==CSML('GridSeriesFeature'):
1011            return 'GridSeriesFeature'
1012        elif tag==CSML('PointFeature'):
1013            return 'PointFeature'
1014        elif tag==CSML('TrajectoryFeature'):
1015            return 'TrajectoryFeature'
1016        elif tag==CSML('PointSeriesFeature'):
1017            return 'PointSeriesFeature'
1018        elif tag==CSML('ProfileFeature'):
1019            return 'ProfileFeature'
1020        elif tag==CSML('ProfileSeriesFeature'):
1021            return 'ProfileSeriesFeature'
1022        elif tag==CSML('RaggedProfileSeriesFeature'):
1023            return 'RaggedProfileSeriesFeature'
1024        elif tag==CSML('RaggedSectionFeature'):
1025            return 'RaggedSectionFeature'
1026        elif tag==CSML('SectionFeature'):
1027            return 'SectionFeature'
1028        elif tag==CSML('ScanningRadarFeature'):
1029            return 'ScanningRadarFeature'
1030        elif tag==CSML('AlternatePointFeature'):
1031            return 'AlternatePointFeature'
1032        else: return 'AbstractFeature'
1033    def _getReverseSubsType(self, typename):
1034        if typename== 'GridFeature':
1035            return CSML('GridFeature')
1036        elif typename == 'GridSeriesFeature':
1037            return CSML('GridSeriesFeature')
1038        elif typename == 'PointSeriesFeature':
1039            return CSML('PointSeriesFeature')
1040        elif typename == 'ProfileFeature':
1041            return CSML('ProfileFeature')
1042        elif typename == 'ProfileSeriesFeature':
1043            return CSML('ProfileSeriesFeature')
1044        elif typename == 'SectionFeature':
1045            return CSML('SectionFeature')
1046        elif typename == 'ScanningRadarFeature':
1047            return CSML('ScanningRadarFeature')
1048        elif typename == 'RaggedSectionFeature':
1049            return CSML('RaggedSectionFeature')
1050        elif typename == 'RaggedProfileSeriesFeature':
1051            return CSML('RaggedProfileSeriesFeature')
1052        elif typename == 'PointFeature':
1053            return CSML('PointFeature')
1054        elif typename == 'TrajectoryFeature':
1055            return CSML('TrajectoryFeature')
1056        elif typename == 'AlternatePointFeature':
1057            return CSML('AlternatePointFeature')
1058        else: return CSML('AbstractFeature')
1059
1060       
1061class Dataset(csElement):   
1062    ''' Dataset class, needed as root of tree'''
1063    def __init__(self, **kwargs):
1064        a=[CSML('id')]
1065        addatts(self,a)
1066        elems=['featureCollection','storageDescriptor']
1067        addelems(self,elems)
1068        children = {elems[0]:[CSML('CSMLFeatureCollection') ,'CSMLFeatureCollection'],elems[1]:[CSML('CSMLStorageDescriptor'), 'CSMLStorageDescriptor']}
1069        addchildren(self,children)
1070        csElement.__init__(self,**kwargs)
1071   
1072    def toXML(self):
1073        csmlfrag=ET.Element(CSML('Dataset'))
1074        csElement.toXML(self, csmlfrag)
1075        return csmlfrag
1076    #def _getSubstitutionType(self,tag): 
1077        #if tag==CSML('NetCDFExtract'):
1078            #return 'NetCDFExtract'
1079        #elif tag==CSML('NASAAmesExtract'):
1080            #return 'NASAAmesExtract'
1081        #else: return 'ArrayDescriptor'
1082    #def _getReverseSubsType(self, typename):
1083        #if typename== 'NetCDFExtract':
1084            #return CSML('NetCDFExtract')
1085        #elif typename == 'NASAAmesExtract':
1086            #return CSML('NASAAmesExtract')
1087        #else: return CSML('ArrayDescriptor')
1088       
1089        return typename
1090
1091   
1092def main():
1093    '''round trip for testing purposes:'''
1094    import parser_extra
1095   
1096    print '\n'
1097    tree=ET.ElementTree(file='testfiles/gridseries/testout.xml')
1098    ds=Dataset()
1099    ds.fromXML(tree.getroot())
1100    csmltree=ds.toXML()
1101   
1102    csmlout=parser_extra.PrettyPrint(csmltree)
1103    csmlout=parser_extra.removeInlineNS(csmlout)
1104    print '\n %s'% csmlout
1105    #for member in ds.featureCollection.members:
1106      #print dir(member.value)
1107       
1108
1109if __name__=='__main__':
1110    main()
Note: See TracBrowser for help on using the repository browser.