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

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

more validation related fixes

Line 
1import cElementTree as ET
2import elementtree.ElementTree as etree
3import sys, traceback
4'''CSML v2 Parser ''' 
5
6#this map needs updating for V2
7etree._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'})
8
9nsCSML = 'http://ndg.nerc.ac.uk/csml'
10nsGML = 'http://www.opengis.net/gml'
11nsOM = 'http://www.opengis.net/om'
12nsXLINK = 'http://www.w3.org/1999/xlink'
13nsXML = 'http://ndg.nerc.ac.uk/csml'
14nsMOLES='http://ndg.nerc.ac.uk/moles'
15nsSWE='http://www.opengis.net/swe'
16   
17def myQName(uri,tag):
18    return "{"+uri+"}"+tag
19
20def CSML(tag):
21    return myQName(nsCSML,tag)
22
23def GML(tag):
24    return myQName(nsGML,tag)
25
26def SWE(tag):
27    return myQName(nsSWE,tag)
28
29def XLINK(tag):
30    return myQName(nsXLINK,tag)
31
32def addchildren(obj, dict):
33    ''' merges (adds) dictionary to existing self.CHILDREN dictionary '''
34    dict1 = dict
35    if hasattr(obj, 'CHILDREN'):
36      dict2=obj.CHILDREN
37    else:
38      dict2={}
39    dict3={}
40    for item in dict1:
41        dict3[item] =dict1[item]
42    for item in dict2:
43        dict3[item] =dict2[item]
44    obj.CHILDREN=dict3
45   
46
47def addatts(obj, atts):
48  ''' merges self.ATTRIBUTES  of inherited classes'''
49  if hasattr(obj, 'ATTRIBUTES'):
50    for att in atts:
51        obj.ATTRIBUTES.append(att)
52  else:
53    obj.ATTRIBUTES=atts
54
55def addelems(obj, elems):
56  ''' merges self.elems of inherited classes'''
57  if hasattr(obj, 'ELEMORDER'):
58    for elem in elems:
59        obj.ELEMORDER.append(elem)
60  else:
61    obj.ELEMORDER=elems
62
63
64#Some variable definitions: these things are often repeated so store in variables.
65FILEFORMATS=[CSML('NetCDFExtract'),CSML('NASAAmesExtract'), CSML('GRIBExtract'),CSML('CDMLExtract'), CSML('RawFileExtract'), CSML('AggregatedArray')]
66
67
68class csElement(object):
69    ''' main csElement class - all other elements inherit from this baseclass 
70    all the from/to XML conversion is done by this class'''
71   
72    def __init__(self, **kwargs):
73        for kw in kwargs:
74            self.__setattr__(kw, kwargs[kw])
75        if not hasattr(self, 'ATTRIBUTES'):
76            self.__dict__['ATTRIBUTES']=[]
77        if not hasattr(self, 'ELEMORDER'):
78            self.__dict__['ELEMORDER']=[]       
79        if not hasattr(self, 'CHILDREN'):
80            self.__dict__['CHILDREN']={}
81    #The __setattr__ and __getattribute__ special methods have been overridden.
82    #This is so that attributes can be called by their fully qualified name internally
83    #while being referenced by their short name externally.
84    # so 'id' and {'http://www.opengis.net/gml'}id always have the same value
85    #you can set either of them at any time and the other will be kept in sync.
86       
87    def __setattr__(self, name, value):
88        if hasattr(self, CSML(name)):
89            object.__setattr__(self, CSML(name), value)
90            object.__setattr__(self, name, value)
91        elif hasattr(self,GML(name)):
92            object.__setattr__(self, GML(name), value)
93            object.__setattr__(self, name, value)
94        elif hasattr(self,XLINK(name)):
95            object.__setattr__(self, XLINK(name), value)
96            object.__setattr__(self, name, value)
97        else:
98            if hasattr(self, 'ATTRIBUTES'):
99                if CSML(name) in self.__dict__['ATTRIBUTES']:
100                    object.__setattr__(self, CSML(name), value)
101                    object.__setattr__(self, name, value)
102                elif GML(name) in self.__dict__['ATTRIBUTES']:
103                    object.__setattr__(self, GML(name), value)
104                    object.__setattr__(self, name, value)
105                elif XLINK(name) in self.__dict__['ATTRIBUTES']:
106                    object.__setattr__(self, XLINK(name), value)
107                    object.__setattr__(self, name, value)
108                elif name in self.__dict__['ATTRIBUTES']:
109                    object.__setattr__(self, name, value)
110                    try:
111                        name=name.split('}')[1]
112                    except IndexError:
113                        pass
114                    object.__setattr__(self, name, value)
115                else:
116                    object.__setattr__(self, name, value)
117            else:
118                    object.__setattr__(self, name, value)
119   
120    def __getattribute__(self, name):
121            if CSML(name) in object.__dict__:
122                return object.__getattribute__(self,CSML(name))
123            elif GML(name) in object.__dict__:
124                return object.__getattribute__(self,GML(name))
125            elif XLINK(name) in object.__dict__:
126                return object.__getattribute__(self,XLINK(name))
127            else:
128                return object.__getattribute__(self,name) 
129       
130    def __removeURI(self, qname):
131        try:
132            attname = qname.split('}')[1]
133        except IndexError:
134            attname = qname
135        return attname
136       
137    def _getSubstitutionType(self,tag):
138        return tag.split('}')[1]
139       
140   
141    def _getReverseSubsType(self, typename):
142        return typename
143   
144    def addChildElem(self, childname, childobj):
145        #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.
146        if hasattr(self, childname):
147            currentattribute=getattr(self,childname)
148            if type(getattr(self,childname)) is list:
149                currentattribute.append(childobj)
150            else:
151                newlist=[currentattribute]
152                newlist.append(childobj)
153                setattr(self,childname, newlist)
154        else:
155            setattr(self,childname, childobj)
156
157    def toXML(self, csmlfrag, **kwargs):
158        #process self and convert to XML
159               
160        if hasattr(self, 'CONTENT'):
161            if self.CONTENT is not None: csmlfrag.text=self.CONTENT
162        if hasattr(self, 'ATTRIBUTES'):
163            for item in self.__dict__:
164                if item in self.ATTRIBUTES:                   
165                    csmlfrag.set(item, self.__dict__[item])
166            for item in self.__dict__:
167                if GML(item) in self.ATTRIBUTES:
168                    csmlfrag.set(GML(item), self.__dict__[item])       
169    # self.CHILDREN (recursive - calls the toXML method of children
170        for child in self.ELEMORDER:
171            if not self.__dict__.has_key(child):
172                continue
173            appendLater=False
174            parserobjects=[]
175            if type(self.__dict__[child]) is list:
176                for a in self.__dict__[child]:
177                    parserobjects.append(a)
178            else:
179                parserobjects.append(self.__dict__[child])
180            parentfrag=None
181            if len(self.CHILDREN[child])>=3:
182                    ename2=self.CHILDREN[child][2]
183                    parentfrag=ET.Element(ename2)
184            for po in parserobjects:
185                if type(self.CHILDREN[child][0]) is not list:
186                    ename=self.CHILDREN[child][0]
187                else:
188                    ename = self._getReverseSubsType(type(po).__name__)
189                if len(self.CHILDREN[child])==3:
190                    frag=ET.Element(ename)
191                    po.toXML(frag)
192                    parentfrag.append(frag)
193                    appendLater=True
194                elif len(self.CHILDREN[child])>=4:
195                    if self.CHILDREN[child][3]==1:
196                        frag=ET.Element(ename)
197                        po.toXML(frag)
198                        parentfrag.append(frag)
199                        csmlfrag.append(parentfrag)
200                        parentfrag=ET.Element(parentfrag.tag)
201                        appendLater=False
202                else:
203                    frag=ET.Element(ename)
204                    try:
205                        po.toXML(frag)
206                    except:
207                        print 'PARSING ERROR - could not convert %s to XML'%frag
208                        print dir(ename)
209                        raise
210                    csmlfrag.append(frag)
211                    appendLater=True
212                if appendLater==True and parentfrag != None:
213                    csmlfrag.append(parentfrag)
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'],'arrayDescriptor':[FILEFORMATS, 'ArrayDescriptor'],  elems[2]:[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(AbstractGML,csElement):
524    def __init__(self, **kwargs):
525        AbstractGML.__init__(self,**kwargs)
526        elems=['coordinateList', 'timePositionList','__insertedExtract']
527        addelems(self,elems)
528        children={elems[0]:[CSML('coordinateList'),'csString'], elems[1]:[CSML('timePositionList'),'TimePositionList'],elems[2]:[FILEFORMATS,'FileExtract',CSML('__insertedExtract')]}
529        addchildren(self,children)
530        csElement.__init__(self,**kwargs)
531
532
533
534class GridOrdinateDescription(AbstractGML,csElement):
535    def __init__(self, **kwargs):
536        AbstractGML.__init__(self,**kwargs)
537        elems=['coordAxisLabel', 'coordAxisValues', 'SpatialOrTemporalPositionList', 'gridAxesSpanned', 'sequenceRule']
538        addelems(self,elems)
539        children={elems[0]:[CSML('coordAxisLabel'), 'csString'], elems[1]:[CSML('SpatialOrTemporalPositionList'),elems[2],CSML('coordAxisValues')], elems[3]:[CSML('gridAxesSpanned'), 'csString'], elems[4]:[CSML('sequenceRule'),'SequenceRule']}
540        addchildren(self,children)
541        csElement.__init__(self,**kwargs)
542       
543class SequenceRule(csElement):
544    def __init__(self, **kwargs):
545        a=['axisOrder']
546        addatts(self,a)
547        children={}
548        addchildren(self,children)
549        csElement.__init__(self,**kwargs)
550       
551class GridPointDescription(AbstractGML,csElement):
552    def __init__(self, **kwargs):
553        AbstractGML.__init__(self,**kwargs)
554        elems=['posList', 'sequenceRule']
555        addelems(self,elems)
556        children={elems[0]:[CSML('posList'),'csString'],elems[1]:[CSML('sequenceRule'),'SequenceRule']}
557        addchildren(self,children)
558        csElement.__init__(self,**kwargs)
559
560class TimePositionList(AbstractGML,csString,csElement):
561    def __init__(self,timeposlist, **kwargs):
562        AbstractGML.__init__(self,**kwargs)
563        csString.__init__(self, timeposlist, **kwargs)
564        elems=[]
565        addelems(self,elems)
566        a=['frame', 'calendarEraName','indeterminatePosition']
567        addatts(self,a)
568        addchildren(self,{})
569        csElement.__init__(self,**kwargs)
570
571class GridCoordinatesTable(AbstractGML,csElement):
572    def __init__(self,**kwargs):
573        '''the additional value '1' in the children dictionary is used to signify that the elements must be nested as:
574        <gml:ordinate>
575            <gml:GridOrdinateDescription>
576        </gml:ordinate>
577        <gml:ordinate>
578            <gml:GridOrdinateDescription>
579        </gml:ordinate>
580       
581        not as:
582        <gml:ordinate>
583            <gml:GridOrdinateDescription>
584            <gml:GridOrdinateDescription>
585        </gml:ordinate> '''
586        AbstractGML.__init__(self,**kwargs)
587        elems=['gridOrdinates' , 'gridPoints']
588        addelems(self,elems)
589        children={elems[0]:[CSML('GridOrdinateDescription'), 'GridOrdinateDescription',CSML('gridOrdinate'),1], elems[1]:[CSML('GridPointDescription'),'GridPointDescription',CSML('gridPoints')]}
590        addchildren(self,children)
591        csElement.__init__(self,**kwargs)
592       
593class Grid(AbstractGML, AssociationAttributeGroup, SRSInformationGroup, SRSReferenceGroup, csElement):
594    def __init__(self, **kwargs):
595        AbstractGML.__init__(self,**kwargs)
596        AssociationAttributeGroup.__init__(self,**kwargs)
597        SRSReferenceGroup.__init__(self,**kwargs)
598        SRSInformationGroup.__init__(self,**kwargs)
599        a=['dimension']
600        addatts(self,a)
601        elems=['limits', 'aLabels','axisName']
602        addelems(self, elems)
603        children = {elems[1]:[CSML('axisLabels'),'csString'],elems[2]:[CSML('axisName'),'csString'], elems[0]:[GML('GridEnvelope'),'GridEnvelope',CSML('limits')]}
604        addchildren(self,children)
605        csElement.__init__(self,**kwargs)
606           
607class ReferenceableGrid(Grid, csElement):
608    def __init__(self, **kwargs):
609        Grid.__init__(self,**kwargs)
610        elems=['coordTransformTable']
611        addelems(self,elems)
612        children={elems[0]:[CSML('GridCoordinatesTable'), 'GridCoordinatesTable', CSML('coordTransformTable')]}
613        addchildren(self,children)
614        csElement.__init__(self,**kwargs)
615
616class ReferenceableGridCoverage(AbstractDiscreteCoverage, csElement):
617    def __init__(self, **kwargs):
618        AbstractDiscreteCoverage.__init__(self,**kwargs)
619        elems=[referenceableGridDomain]
620        addelems(self,elems)
621        children={elems[0]:[CSML('ReferenceableGrid'),'ReferenceableGrid' ,CSML('referenceableGridDomain') ]}
622        addchildren(self,children)
623        csElement.__init__(self,**kwargs)
624       
625class AlternatePointCoverage(AbstractDiscreteCoverage, csElement):
626    def __init__(self, **kwargs):
627        AbstractDiscreteCoverage.__init__(self,**kwargs)
628        elems=['alternatePointDomain','rangeSet','coverageFunction']
629        addelems(self,elems)
630        children={elems[0]:[GML('Point'),'Point', CSML('alternatePointDomain')], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
631        addchildren(self,children)
632        csElement.__init__(self,**kwargs)
633
634class ProfileCoverage(AbstractDiscreteCoverage, csElement):
635    def __init__(self, **kwargs):
636        AbstractDiscreteCoverage.__init__(self,**kwargs)
637        elems=['profileDomain', 'rangeSet' ,'coverageFunction']
638        addelems(self,elems)
639        children={elems[0]:[CSML('ProfileDomain'),'ProfileDomain' ,CSML('profileDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
640        addchildren(self,children)
641        csElement.__init__(self,**kwargs)
642       
643class PointCoverage(AbstractDiscreteCoverage, csElement):
644    def __init__(self, **kwargs):
645        AbstractDiscreteCoverage.__init__(self,**kwargs)
646        elems=['pointDomain','rangeSet', 'coverageFunction']
647        addelems(self,elems)
648        children={elems[0]:[CSML('PointDomain'),'PointDomain' ,CSML('pointDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
649        addchildren(self,children)
650        csElement.__init__(self,**kwargs)
651       
652class TimeSeries(AbstractGML, csElement):
653    def __init__(self, **kwargs):
654        AbstractGML.__init__(self,**kwargs)
655        elems=['timePositionList']
656        addelems(self,elems)
657        children={elems[0]:[CSML('timePositionList'), 'csString']}
658        addchildren(self,children)
659        csElement.__init__(self,**kwargs)
660
661class PointSeriesCoverage(AbstractDiscreteCoverage, csElement):
662    def __init__(self, **kwargs):
663        AbstractDiscreteCoverage.__init__(self,**kwargs)
664        elems=['pointSeriesDomain','rangeSet','coverageFunction']
665        addelems(self,elems)
666        children={elems[0]:[CSML('TimeSeries'),'TimeSeries' ,CSML('pointSeriesDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
667        addchildren(self,children)
668        csElement.__init__(self,**kwargs)
669       
670class ProfileSeriesDomain(ReferenceableGrid, DomainSet, csElement):
671    def __init__(self, **kwargs):
672        DomainSet.__init__(self,**kwargs)
673        ReferenceableGrid.__init__(self,**kwargs)
674        children={}
675        addchildren(self,children)
676        csElement.__init__(self,**kwargs)
677       
678class ProfileSeriesCoverage(AbstractDiscreteCoverage,csElement):
679    def __init__(self, **kwargs):
680        AbstractDiscreteCoverage.__init__(self,**kwargs)
681        elems=['profileSeriesDomain', 'rangeSet', 'coverageFunction']
682        addelems(self,elems)
683        children={elems[0]:[CSML('ProfileSeriesDomain'),'ProfileSeriesDomain' ,CSML('profileSeriesDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
684        addchildren(self,children)
685        csElement.__init__(self,**kwargs)
686       
687class SectionDomain(ReferenceableGrid, DomainSet, csElement):
688    def __init__(self, **kwargs):
689        DomainSet.__init__(self,**kwargs)
690        ReferenceableGrid.__init__(self,**kwargs)
691        children={}
692        addchildren(self,children)
693        csElement.__init__(self,**kwargs)
694       
695class SectionCoverage(AbstractDiscreteCoverage,csElement):
696    def __init__(self, **kwargs):
697        AbstractDiscreteCoverage.__init__(self,**kwargs)
698        elems=['sectionDomain', 'rangeSet' , 'coverageFunction']
699        addelems(self,elems)
700        children={elems[0]:[CSML('SectionDomain'),'SectionDomain' ,CSML('sectionDomain') ],elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
701        addchildren(self,children)
702        csElement.__init__(self,**kwargs)
703       
704class TrajectoryDomain(ReferenceableGrid, DomainSet, csElement):
705    def __init__(self, **kwargs):
706        DomainSet.__init__(self,**kwargs)
707        ReferenceableGrid.__init__(self,**kwargs)
708        children={}
709        addchildren(self,children)
710        csElement.__init__(self,**kwargs)
711       
712class TrajectoryCoverage(AbstractDiscreteCoverage,csElement):
713    def __init__(self, **kwargs):
714        AbstractDiscreteCoverage.__init__(self,**kwargs)
715        elems=['trajectoryDomain', 'rangeSet', 'coverageFunction']
716        addelems(self,elems)
717        children={elems[0]:[CSML('TrajectoryDomain'),'TrajectoryDomain' ,CSML('trajectoryDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
718        addchildren(self,children)
719        csElement.__init__(self,**kwargs)
720
721class ScanningRadarDomain(ReferenceableGrid, DomainSet, csElement):
722    def __init__(self, **kwargs):
723        DomainSet.__init__(self,**kwargs)
724        ReferenceableGrid.__init__(self,**kwargs)
725        children={}
726        addchildren(self,children)
727        csElement.__init__(self,**kwargs)
728       
729class ScanningRadarCoverage(AbstractDiscreteCoverage,csElement):
730    def __init__(self, **kwargs):
731        AbstractDiscreteCoverage.__init__(self,**kwargs)
732        elems=['scanningRadarDomain', 'rangeSet','coverageFunction']
733        addelems(self,elems)
734        children={elems[0]:[CSML('ScanningRadarDomain'),'ScanningRadarDomain' ,CSML('scanningRadarDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
735        addchildren(self,children)
736        csElement.__init__(self,**kwargs)
737
738
739class GridSeriesDomain(ReferenceableGrid, csElement):
740    def __init__(self, **kwargs):
741        #DomainSet.__init__(self,**kwargs)
742        ReferenceableGrid.__init__(self,**kwargs)
743        children={}
744        addchildren(self,children)
745        csElement.__init__(self,**kwargs)
746
747class GridSeriesCoverage(AbstractDiscreteCoverage,csElement):
748    def __init__(self, **kwargs):
749        elems=['gridSeriesDomain', 'rangeSet', 'coverageFunction']
750        addelems(self,elems)
751        children={elems[0]:[CSML('GridSeriesDomain'),'GridSeriesDomain' ,CSML('gridSeriesDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
752        addchildren(self,children)
753        AbstractDiscreteCoverage.__init__(self,**kwargs)
754        csElement.__init__(self,**kwargs)
755
756class AlternatePointFeature(AbstractFeature, csElement):
757    def __init__(self, **kwargs):
758        AbstractFeature.__init__(self,**kwargs)
759        elems=['location', 'time', 'value','parameter']
760        addelems(self,elems)
761        children={elems[0]:[CSML('location'), 'csString'],elems[1]:[CSML('time'), 'csString'], elems[2]:[CSML('AlternatePointCoverage'), 'AlternatePointCoverage', CSML('value')],elems[3]:[CSML('parameter'), 'Phenomenon']}
762        addchildren(self,children)
763        csElement.__init__(self,**kwargs)
764
765class DirectPositionList(SRSReferenceGroup, csElement):
766    def __init__(self, **kwargs):
767        SRSReferenceGroup.__init__(self,**kwargs)
768        children=[]
769        addchildren(self,children)
770        csElement.__init__(self,**kwargs)
771       
772class PointFeature(AbstractFeature, csElement):
773    def __init__(self, **kwargs):
774        AbstractFeature.__init__(self,**kwargs)
775        elems=['location', 'time', 'value','parameter']
776        addelems(self,elems)
777        children={elems[0]:[CSML('location'), 'DirectPositionList'],elems[1]:[CSML('time'), 'csString'], elems[2]:[CSML('PointCoverage'), 'PointCoverage', CSML('value')], elems[3]:[CSML('parameter'), 'Phenomenon']}
778        addchildren(self,children)
779        csElement.__init__(self,**kwargs)
780
781class PointCollectionFeature(AbstractFeature, csElement):
782    def __init__(self, **kwargs):
783        AbstractFeature.__init__(self,**kwargs)
784        elems=['time', 'value', 'parameter']
785        addelems(self,elems)
786        children={elems[0]:[CSML('time'), 'csString'], elems[1]:[CSML('MultiPointCoverage'), 'MultiPointCoverage', CSML('value')], elems[2]:[CSML('parameter'), 'Phenomenon']}
787        addchildren(self,children)
788        csElement.__init__(self,**kwargs)
789
790
791class PointSeriesFeature(AbstractFeature, csElement):
792    def __init__(self, **kwargs):
793        AbstractFeature.__init__(self,**kwargs)
794        elems=['location','value','parameter']
795        addelems(self,elems)
796        children={elems[0]:[CSML('location'), 'csString'], elems[1]:[CSML('PointSeriesCoverage'), 'PointSeriesCoverage', CSML('value')], elems[2]:[CSML('parameter'), 'Phenomenon']}
797        addchildren(self,children)
798        csElement.__init__(self,**kwargs)
799
800
801class GridFeature(AbstractFeature, csElement):
802    def __init__(self, **kwargs):
803        AbstractFeature.__init__(self,**kwargs)
804        elems=['time', 'value', 'parameter']
805        addelems(self,elems)
806        children={elems[0]:[CSML('time'), 'csString'], elems[1]:[CSML('ReferenceableGridCoverage'), 'ReferenceableGridCoverage', CSML('value')], elems[2]:[CSML('parameter'), 'Phenomenon']}
807        addchildren(self,children)
808        csElement.__init__(self,**kwargs)
809
810class GridSeriesFeature(AbstractFeature, csElement):
811    def __init__(self, **kwargs):
812        AbstractFeature.__init__(self,**kwargs)
813        elems=['value','parameter']
814        addelems(self,elems)
815        children={elems[0]:[CSML('GridSeriesCoverage'), 'GridSeriesCoverage', CSML('value')],elems[1]:[CSML('parameter'), 'Phenomenon']}
816        addchildren(self,children)
817        csElement.__init__(self,**kwargs)
818
819class ProfileFeature(AbstractFeature, csElement):
820    def __init__(self, **kwargs):
821        AbstractFeature.__init__(self,**kwargs)
822        elems=['time', 'location', 'value', 'parameter']
823        addelems(self,elems)
824        children={elems[0]:[CSML('time'), 'csString'],elems[1]:[CSML('location'), 'csString'], elems[2]:[CSML('ProfileCoverage'), 'ProfileCoverage', CSML('value')], elems[3]:[CSML('parameter'), 'Phenomenon']}
825        addchildren(self,children)
826        csElement.__init__(self,**kwargs)
827
828class ProfileSeriesFeature(AbstractFeature, csElement):
829    def __init__(self, **kwargs):
830        AbstractFeature.__init__(self,**kwargs)
831        elems=['location', 'value', 'parameter']
832        addelems(self,elems)
833        children={elems[0]:[CSML('location'), 'csString'], elems[1]:[CSML('ProfileSeriesCoverage'), 'ProfileSeriesCoverage', CSML('value')], elems[2]:[CSML('parameter'), 'Phenomenon']}
834        addchildren(self,children)
835        csElement.__init__(self,**kwargs)
836
837class RaggedProfileSeriesFeature(AbstractFeature, csElement):
838    def __init__(self, **kwargs):
839        AbstractFeature.__init__(self,**kwargs)
840        elems=['location', 'profileLength', 'value', 'parameter']
841        addelems(self,elems)
842        children={elems[0]:[CSML('location'), 'csString'], elems[1]:[CSML('profileLength'), 'csString'],elems[2]:[CSML('ProfileSeriesCoverage'), 'ProfileSeriesCoverage', CSML('value')], elems[3]:[CSML('parameter'), 'Phenomenon']}
843        addchildren(self,children)
844        csElement.__init__(self,**kwargs)
845
846class RaggedSectionFeature(AbstractFeature, csElement):
847    def __init__(self, **kwargs):
848        AbstractFeature.__init__(self,**kwargs)
849        elems=['stationLocations', 'stationTimes', 'profileLength' 'value','parameter']
850        addelems(self,elems)
851        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']}
852        addchildren(self,children)
853        csElement.__init__(self,**kwargs)
854
855class SectionFeature(AbstractFeature, csElement):
856    def __init__(self, **kwargs):
857        AbstractFeature.__init__(self,**kwargs)
858        elems=['stationLocations', 'stationTimes','value', 'parameter']
859        addelems(self,elems)
860        children={elems[0]:[CSML('stationLocations'), 'csString'], elems[1]:[CSML('stationTimes'), 'TimePositionList'],elems[2]:[CSML('SectionCoverage'), 'SectionCoverage', CSML('value')], elems[3]:[CSML('parameter'), 'Phenomenon']}
861        addchildren(self,children)
862        csElement.__init__(self,**kwargs)
863
864class ScanningRadarFeature(AbstractFeature, csElement):
865    def __init__(self, **kwargs):
866        AbstractFeature.__init__(self,**kwargs)
867        elems=['elevation','value', 'parameter']
868        addelems(self,elems)
869        children={elems[0]:[CSML('elevation'), 'csString'], elems[1]:[CSML('ScanningRadarCoverage'), 'ScanningRadarCoverage', CSML('value')], elems[2]:[CSML('parameter'), 'Phenomenon']}
870        addchildren(self,children)
871        csElement.__init__(self,**kwargs)
872
873       
874class SwathFeature(AbstractFeature, csElement):
875    def __init__(self, **kwargs):
876        AbstractFeature.__init__(self,**kwargs)
877        elems=['eqCrossLon', 'eqCrossTime', 'value', 'parameter']
878        addelems(self,elems)
879        children={elems[0]:[CSML('eqCrossLon'), 'csString'],elems[1]:[CSML('eqCrossTime'), 'csString'], elems[2]:[CSML('ReferenceableGridCoverage'), 'ReferenceableGridCoverage', CSML('value')], elems[3]:[CSML('parameter'), 'Phenomenon']}
880        addchildren(self,children)
881        csElement.__init__(self,**kwargs)
882       
883class TrajectoryFeature(AbstractFeature, csElement):
884    def __init__(self, **kwargs):
885        AbstractFeature.__init__(self,**kwargs)
886        elems=['value', 'parameter']
887        addelems(self,elems)
888        children={elems[0]:[CSML('TrajectoryCoverage'), 'TrajectoryCoverage', CSML('value')], elems[1]:[CSML('parameter'), 'Phenomenon']}
889        addchildren(self,children)
890        csElement.__init__(self,**kwargs)
891       
892class FileList(AssociationAttributeGroup,AbstractGML,csElement):
893    def __init__(self,**kwargs):
894        elems=['fileNames']
895        addelems(self,elems)
896        AssociationAttributeGroup.__init__(self,**kwargs)
897        AbstractGML.__init__(self,**kwargs)
898        addatts(self,[])
899        children= {elems[0]:[CSML('fileNames'), 'csString']}
900        addchildren(self,children)
901        csElement.__init__(self,**kwargs)
902       
903class FileExtract(ArrayDescriptor, csElement):
904    def __init__(self,**kwargs):
905        ArrayDescriptor.__init__(self,**kwargs)
906        elems=['fileName', 'fileList', 'fileListXLINK']
907        addelems(self,elems)
908        children= {elems[0]:[CSML('fileName'), 'csString'],  elems[1]:[CSML('FileList'), 'FileList', CSML('fileList')],elems[2]:[CSML('fileList'), 'csString']}
909        addchildren(self,children)
910        csElement.__init__(self,**kwargs)
911
912class NetCDFExtract(FileExtract, csElement):
913    def __init__(self,**kwargs):
914        FileExtract.__init__(self, **kwargs)
915        elems=['variableName']
916        addelems(self,elems)
917        children={elems[0]:[CSML('variableName'), 'csString']}
918        addchildren(self,children)
919        csElement.__init__(self,**kwargs)
920
921class NASAAmesExtract(FileExtract, csElement):
922    def __init__(self,**kwargs):
923        FileExtract.__init__(self, **kwargs)
924        elems=['variableName', 'index']
925        addelems(self,elems)
926        children={elems[0]:[CSML('variableName'), 'csString'],elems[1]:[CSML('index'),'csString']}
927        addchildren(self,children)
928        csElement.__init__(self,**kwargs)
929
930class CSMLStorageDescriptor(csElement):
931    def __init__(self,**kwargs):
932        addatts(self,[])
933        elems=['descriptors']
934        addelems(self,elems)
935        children={elems[0]:[[CSML('NetCDFExtract'),CSML('AggregatedArray')], 'FileExtract', CSML('descriptor'),1]}
936        addchildren(self,children)
937        csElement.__init__(self,**kwargs)
938
939class CSMLFeatureCollection(AbstractFeatureCollection,csElement,):
940    def __init__(self,**kwargs):
941        AbstractFeatureCollection.__init__(self,**kwargs)
942        elems=['featureMembers']
943        addelems(self,elems)
944        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]}
945        addchildren(self,children)
946        csElement.__init__(self,**kwargs)
947    def _getSubstitutionType(self,tag):
948        if tag==CSML('GridFeature'):
949            return 'GridFeature'
950        elif tag==CSML('GridSeriesFeature'):
951            return 'GridSeriesFeature'
952        elif tag==CSML('PointFeature'):
953            return 'PointFeature'
954        elif tag==CSML('TrajectoryFeature'):
955            return 'TrajectoryFeature'
956        elif tag==CSML('PointSeriesFeature'):
957            return 'PointSeriesFeature'
958        elif tag==CSML('ProfileFeature'):
959            return 'ProfileFeature'
960        elif tag==CSML('ProfileSeriesFeature'):
961            return 'ProfileSeriesFeature'
962        elif tag==CSML('RaggedProfileSeriesFeature'):
963            return 'RaggedProfileSeriesFeature'
964        elif tag==CSML('RaggedSectionFeature'):
965            return 'RaggedSectionFeature'
966        elif tag==CSML('SectionFeature'):
967            return 'SectionFeature'
968        elif tag==CSML('ScanningRadarFeature'):
969            return 'ScanningRadarFeature'
970        elif tag==CSML('AlternatePointFeature'):
971            return 'AlternatePointFeature'
972        else: return 'AbstractFeature'
973    def _getReverseSubsType(self, typename):
974        if typename== 'GridFeature':
975            return CSML('GridFeature')
976        elif typename == 'GridSeriesFeature':
977            return CSML('GridSeriesFeature')
978        elif typename == 'PointSeriesFeature':
979            return CSML('PointSeriesFeature')
980        elif typename == 'ProfileFeature':
981            return CSML('ProfileFeature')
982        elif typename == 'ProfileSeriesFeature':
983            return CSML('ProfileSeriesFeature')
984        elif typename == 'SectionFeature':
985            return CSML('SectionFeature')
986        elif typename == 'ScanningRadarFeature':
987            return CSML('ScanningRadarFeature')
988        elif typename == 'RaggedSectionFeature':
989            return CSML('RaggedSectionFeature')
990        elif typename == 'RaggedProfileSeriesFeature':
991            return CSML('RaggedProfileSeriesFeature')
992        elif typename == 'PointFeature':
993            return CSML('PointFeature')
994        elif typename == 'TrajectoryFeature':
995            return CSML('TrajectoryFeature')
996        elif typename == 'AlternatePointFeature':
997            return CSML('AlternatePointFeature')
998        else: return CSML('AbstractFeature')
999
1000       
1001class Dataset(csElement):   
1002    ''' Dataset class, needed as root of tree'''
1003    def __init__(self, **kwargs):
1004        a=[CSML('id')]
1005        addatts(self,a)
1006        elems=['featureCollection','storageDescriptor']
1007        addelems(self,elems)
1008        children = {elems[0]:[CSML('CSMLFeatureCollection') ,'CSMLFeatureCollection'],elems[1]:[CSML('CSMLStorageDescriptor'), 'CSMLStorageDescriptor']}
1009        addchildren(self,children)
1010        csElement.__init__(self,**kwargs)
1011   
1012    def toXML(self):
1013        csmlfrag=ET.Element(CSML('Dataset'))
1014        csElement.toXML(self, csmlfrag)
1015        return csmlfrag
1016    #def _getSubstitutionType(self,tag): 
1017        #if tag==CSML('NetCDFExtract'):
1018            #return 'NetCDFExtract'
1019        #elif tag==CSML('NASAAmesExtract'):
1020            #return 'NASAAmesExtract'
1021        #else: return 'ArrayDescriptor'
1022    #def _getReverseSubsType(self, typename):
1023        #if typename== 'NetCDFExtract':
1024            #return CSML('NetCDFExtract')
1025        #elif typename == 'NASAAmesExtract':
1026            #return CSML('NASAAmesExtract')
1027        #else: return CSML('ArrayDescriptor')
1028       
1029        return typename
1030
1031   
1032def main():
1033    '''round trip for testing purposes:'''
1034    import parser_extra
1035   
1036    print '\n'
1037    tree=ET.ElementTree(file='test.xml')
1038    ds=Dataset()
1039    ds.fromXML(tree.getroot())
1040    csmltree=ds.toXML()
1041   
1042    csmlout=parser_extra.PrettyPrint(csmltree)
1043    csmlout=parser_extra.removeInlineNS(csmlout)
1044    print '\n %s'% csmlout
1045    #for member in ds.featureCollection.members:
1046      #print dir(member.value)
1047       
1048
1049if __name__=='__main__':
1050    main()
Note: See TracBrowser for help on using the repository browser.