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

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

gml:name now used for variable name, gml:id becomes opaque identifer

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')]
288        addatts(self,a)
289        elems=['metaDataProperty', 'description','name']
290        addelems(self,elems)
291        children={elems[0]:[GML('metaDataProperty'),'csString'],elems[1]:[GML('description'),'csString'],elems[2]:[GML('name'),'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.