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

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

various fixes related to schema validation

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(AbstractGML, csElement):
327    def __init__(self,**kwargs):
328        AbstractGML.__init__(self,**kwargs)
329        elems=['arraySize', 'uom', 'numericType','regExpTransform','numericTransform']
330        addelems(self,elems)
331        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']}
332        addchildren(self,children)
333        csElement.__init__(self,**kwargs)
334               
335class GridEnvelope(AbstractGML,SRSReferenceGroup, csElement):
336    def __init__(self, **kwargs):
337        SRSReferenceGroup.__init__(self,**kwargs)
338        AbstractGML.__init__(self,**kwargs)
339        elems=['low', 'high']
340        addelems(self,elems)
341        children={elems[0]:[GML('low'), 'csString'],elems[1]:[GML('high'), 'csString']}
342        addchildren(self,children)
343        csElement.__init__(self,**kwargs)
344       
345class Envelope(AbstractGML,SRSReferenceGroup, csElement):
346    def __init__(self, **kwargs):
347        SRSReferenceGroup.__init__(self,**kwargs)
348        AbstractGML.__init__(self,**kwargs)
349        elems=['lowerCorner','upperCorner']
350        addelems(self,elems)
351        children={elems[0]:[GML('lowerCorner'), 'csString'],elems[1]:[GML('upperCorner'), 'csString']}
352        addchildren(self,children)
353        csElement.__init__(self,**kwargs)
354       
355class EnvelopeWithTimePeriod(Envelope):
356    def __init__(self, **kwargs):
357        Envelope.__init__(self,**kwargs)
358        elems=['beginPosition', 'endPosition']
359        addelems(self,elems)
360        children={elems[0]:[GML('beginPosition'), 'csString'], elems[1]:[GML('endPosition'), 'csString']}
361        addchildren(self,children)
362        csElement.__init__(self,**kwargs)
363
364class AbstractFeature(AbstractGML,csElement):
365    def __init__(self, **kwargs):
366        AbstractGML.__init__(self,**kwargs)
367        elems=['boundedBy']
368        addelems(self,elems)
369        #this pattern works but can only accept EnvelopeWithTimePeriod for the boundedBy,
370        #which is probably ok   
371        children={elems[0]:[GML('EnvelopeWithTimePeriod'), 'EnvelopeWithTimePeriod', GML('boundedBy')]}
372        addchildren(self,children)
373        csElement.__init__(self,**kwargs)
374       
375class AbstractFeatureCollection(AbstractFeature,csElement):
376    def __init__(self, **kwargs):
377        AbstractFeature.__init__(self,**kwargs)
378        csElement.__init__(self,**kwargs)
379       
380class DomainSet(AbstractGML,AssociationAttributeGroup,csElement):
381    def __init__(self, **kwargs):
382        AbstractGML.__init__(self,**kwargs)
383        addchildren(self,{})
384        csElement.__init__(self,**kwargs)
385       
386class AggregatedArray(ArrayDescriptor,csElement):
387    def __init__(self, **kwargs):
388        ArrayDescriptor.__init__(self,**kwargs)
389        elems=['aggType', 'aggIndex', 'components']
390        addelems(self,elems)
391        children={elems[0]:[CSML('aggType'),'csString'], elems[1]:[CSML('aggIndex'),'csString'],elems[2]:[FILEFORMATS, 'ArrayDescriptor',CSML('component')]}
392        addchildren(self,children)
393        csElement.__init__(self,**kwargs)
394#'component':[CSML:('component'), 'ArrayDescriptor', CSML('component')],
395class MeasureOrNullList(AbstractGML,csElement):
396    def __init__(self, **kwargs):
397        AbstractGML.__init__(self,**kwargs)
398        elems=['__insertedExtract']  # should this be here ? check
399        addelems(self,elems)
400        #note __insertedExtract is used in resolving xlinks and shouldn't be written to directly (except by the code which handles the xlink resolutions)
401        children={elems[0]:[FILEFORMATS,'FileExtract',CSML('__insertedExtract')]}
402        addchildren(self,children)
403        a =['uom'] 
404        addatts(self,a)
405        csElement.__init__(self,**kwargs)
406       
407       
408class CompositeValue(AbstractGML,csElement):
409    def __init__(self, **kwargs):
410        AbstractGML.__init__(self,**kwargs)
411        elems=['measures']
412        addelems(self,elems)
413        children={elems[0]:[GML('measure'),'csString',GML('valueComponents')]}
414        addchildren(self,children)
415        csElement.__init__(self,**kwargs)
416       
417class DataBlock(AbstractGML,csElement):
418    #THIS IS INCOMPLETE
419    def __init__(self, **kwargs):
420        AbstractGML.__init__(self,**kwargs)
421        elems=['doubleOrNullTupleList','rangeParameters']
422        addelems(self,elems)
423        children={elems[0]:[GML('doubleOrNullTupleList'),'csString'],elems[1]:[GML('CompositeValue'), 'CompositeValue', GML('rangeParameters')]}
424        addchildren(self,children)
425        csElement.__init__(self,**kwargs)
426
427class ValueComponent(AbstractGML, AssociationAttributeGroup, csElement):
428    def __init__(self, **kwargs):
429        AbstractGML.__init__(self,**kwargs)
430        AssociationAttributeGroup.__init__(self,**kwargs)
431        elems=['quantityList']
432        addelems(self,elems)
433        children=children={elems[0]:[GML('QuantityList'), 'MeasureOrNullList']}
434        addchildren(self,children)
435        csElement.__init__(self,**kwargs)
436
437class ValueArray(AbstractGML, csElement):
438    def __init__(self, **kwargs):
439        AbstractGML.__init__(self,**kwargs)
440        elems=['valueComponent']
441        addelems(self,elems)
442        #this is a bit of a diversion from the object/property pattern but is necessary to
443        #make valueComponent a class so valueComponent can have xlink attributes
444        children=children={elems[0]:[GML('valueComponent'), 'ValueComponent', ]}
445        addchildren(self,children)
446        csElement.__init__(self,**kwargs)
447       
448
449class RangeSet(AbstractGML,AssociationAttributeGroup,csElement):
450    def __init__(self, **kwargs):
451        AbstractGML.__init__(self,**kwargs)
452        AssociationAttributeGroup.__init__(self,**kwargs)
453        elems=['quantityList', 'dataBlock', 'arrayDescriptor']
454        addelems(self,elems)
455        children={elems[0]:[GML('QuantityList'), 'MeasureOrNullList'],        elems[1]:[GML('DataBlock'),'DataBlock'],'arrayDescriptor':[FILEFORMATS, 'ArrayDescriptor'],  elems[2]:[CSML('AggregatedArray'), 'AggregatedArray'],
456        'valueArray':[GML('ValueArray'),'ValueArray']}
457        addchildren(self,children)
458        csElement.__init__(self,**kwargs)
459       
460class MultiPoint(AbstractGML, SRSReferenceGroup,csElement):
461    def __init__(self, **kwargs):
462        AbstractGML.__init__(self,**kwargs)
463        SRSReferenceGroup.__init__(self,**kwargs)
464        elems=['pointMember','pointMembers']
465        addelems(self,elems)
466        children={elems[0]:[GML('pointMember'), 'csString'],elems[0]:[GML('pointMember'), 'csString']}
467        addchildren(self,children)
468        csElement.__init__(self,**kwargs)
469       
470class Point(AbstractGML,SRSReferenceGroup,csElement):
471    def __init__(self, **kwargs):
472        AbstractGML.__init__(self,**kwargs)
473        SRSReferenceGroup.__init__(self,**kwargs)
474        elems=['pos','coordinates']
475        addelems(self,elems)
476        children={elems[0]:[GML('pos'), 'csString'],elems[1]:[GML('coordinates'), 'csString']}
477        addchildren(self,children)
478        csElement.__init__(self,**kwargs)
479       
480class PointDomain(DomainSet, MultiPoint,csElement):
481    def __init__(self, **kwargs):
482        DomainSet.__init__(self,**kwargs)
483        MultiPoint.__init__(self,**kwargs)
484        children={}
485        addchildren(self,children)
486        csElement.__init__(self,**kwargs)
487       
488class ProfileDomain(DomainSet, MultiPoint,csElement):
489    def __init__(self, **kwargs):
490        DomainSet.__init__(self,**kwargs)
491        MultiPoint.__init__(self,**kwargs)
492        children={}
493        addchildren(self,children)
494        csElement.__init__(self,**kwargs)
495
496
497class AbstractCoverage(AbstractFeature, csElement):
498    def __init__(self, **kwargs):
499        AbstractFeature.__init__(self,**kwargs)
500        csElement.__init__(self,**kwargs)
501       
502class AbstractDiscreteCoverage(AbstractCoverage, csElement):
503    def __init__(self, **kwargs):
504        AbstractCoverage.__init__(self,**kwargs)
505        addchildren(self,{})
506        csElement.__init__(self,**kwargs)
507       
508class Definition(AbstractGML):
509    def __init__(self, **kwargs):
510        AbstractGML.__init__(self,**kwargs)
511        addchildren(self,{})
512        csElement.__init__(self,**kwargs)
513       
514class Phenomenon(Definition,AssociationAttributeGroup):
515    def __init__(self, **kwargs):
516        Definition.__init__(self,**kwargs)
517        AssociationAttributeGroup.__init__(self,**kwargs)
518        children = {'':[CSML(''), '']}   
519        addchildren(self,children)
520        csElement.__init__(self,**kwargs)
521               
522class SpatialOrTemporalPositionList(AbstractGML,csElement):
523    def __init__(self, **kwargs):
524        AbstractGML.__init__(self,**kwargs)
525        elems=['coordinateList', 'timePositionList','__insertedExtract']
526        addelems(self,elems)
527        children={elems[0]:[CSML('coordinateList'),'csString'], elems[1]:[CSML('timePositionList'),'TimePositionList'],elems[2]:[FILEFORMATS,'FileExtract',CSML('__insertedExtract')]}
528        addchildren(self,children)
529        csElement.__init__(self,**kwargs)
530
531
532
533class GridOrdinateDescription(AbstractGML,csElement):
534    def __init__(self, **kwargs):
535        AbstractGML.__init__(self,**kwargs)
536        elems=['coordAxisLabel', 'coordAxisValues', 'SpatialOrTemporalPositionList', 'gridAxesSpanned', 'sequenceRule']
537        addelems(self,elems)
538        children={elems[0]:[CSML('coordAxisLabel'), 'csString'], elems[1]:[CSML('SpatialOrTemporalPositionList'),elems[2],CSML('coordAxisValues')], elems[3]:[CSML('gridAxesSpanned'), 'csString'], elems[4]:[CSML('sequenceRule'),'SequenceRule']}
539        addchildren(self,children)
540        csElement.__init__(self,**kwargs)
541       
542class SequenceRule(csElement):
543    def __init__(self, **kwargs):
544        a=['axisOrder']
545        addatts(self,a)
546        children={}
547        addchildren(self,children)
548        csElement.__init__(self,**kwargs)
549       
550class GridPointDescription(AbstractGML,csElement):
551    def __init__(self, **kwargs):
552        AbstractGML.__init__(self,**kwargs)
553        elems=['posList', 'sequenceRule']
554        addelems(self,elems)
555        children={elems[0]:[CSML('posList'),'csString'],elems[1]:[CSML('sequenceRule'),'SequenceRule']}
556        addchildren(self,children)
557        csElement.__init__(self,**kwargs)
558
559class TimePositionList(AbstractGML,csString,csElement):
560    def __init__(self,timeposlist, **kwargs):
561        AbstractGML.__init__(self,**kwargs)
562        csString.__init__(self, timeposlist, **kwargs)
563        elems=[]
564        addelems(self,elems)
565        a=['frame', 'calendarEraName','indeterminatePosition']
566        addatts(self,a)
567        addchildren(self,{})
568        csElement.__init__(self,**kwargs)
569
570class GridCoordinatesTable(AbstractGML,csElement):
571    def __init__(self,**kwargs):
572        '''the additional value '1' in the children dictionary is used to signify that the elements must be nested as:
573        <gml:ordinate>
574            <gml:GridOrdinateDescription>
575        </gml:ordinate>
576        <gml:ordinate>
577            <gml:GridOrdinateDescription>
578        </gml:ordinate>
579       
580        not as:
581        <gml:ordinate>
582            <gml:GridOrdinateDescription>
583            <gml:GridOrdinateDescription>
584        </gml:ordinate> '''
585        AbstractGML.__init__(self,**kwargs)
586        elems=['gridOrdinates' , 'gridPoints']
587        addelems(self,elems)
588        children={elems[0]:[CSML('GridOrdinateDescription'), 'GridOrdinateDescription',CSML('gridOrdinate'),1], elems[1]:[CSML('GridPointDescription'),'GridPointDescription',CSML('gridPoints')]}
589        addchildren(self,children)
590        csElement.__init__(self,**kwargs)
591       
592class Grid(AbstractGML, AssociationAttributeGroup, SRSInformationGroup, SRSReferenceGroup, csElement):
593    def __init__(self, **kwargs):
594        AbstractGML.__init__(self,**kwargs)
595        AssociationAttributeGroup.__init__(self,**kwargs)
596        SRSReferenceGroup.__init__(self,**kwargs)
597        SRSInformationGroup.__init__(self,**kwargs)
598        a=['dimension']
599        addatts(self,a)
600        elems=['limits', 'aLabels','axisName']
601        addelems(self, elems)
602        children = {elems[1]:[CSML('axisLabels'),'csString'],elems[2]:[CSML('axisName'),'csString'], elems[0]:[GML('GridEnvelope'),'GridEnvelope',CSML('limits')]}
603        addchildren(self,children)
604        csElement.__init__(self,**kwargs)
605           
606class ReferenceableGrid(Grid, csElement):
607    def __init__(self, **kwargs):
608        Grid.__init__(self,**kwargs)
609        elems=['coordTransformTable']
610        addelems(self,elems)
611        children={elems[0]:[CSML('GridCoordinatesTable'), 'GridCoordinatesTable', CSML('coordTransformTable')]}
612        addchildren(self,children)
613        csElement.__init__(self,**kwargs)
614
615class ReferenceableGridCoverage(AbstractDiscreteCoverage, csElement):
616    def __init__(self, **kwargs):
617        AbstractDiscreteCoverage.__init__(self,**kwargs)
618        elems=[referenceableGridDomain]
619        addelems(self,elems)
620        children={elems[0]:[CSML('ReferenceableGrid'),'ReferenceableGrid' ,CSML('referenceableGridDomain') ]}
621        addchildren(self,children)
622        csElement.__init__(self,**kwargs)
623       
624class AlternatePointCoverage(AbstractDiscreteCoverage, csElement):
625    def __init__(self, **kwargs):
626        AbstractDiscreteCoverage.__init__(self,**kwargs)
627        elems=['alternatePointDomain','rangeSet','coverageFunction']
628        addelems(self,elems)
629        children={elems[0]:[GML('Point'),'Point', CSML('alternatePointDomain')], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
630        addchildren(self,children)
631        csElement.__init__(self,**kwargs)
632
633class ProfileCoverage(AbstractDiscreteCoverage, csElement):
634    def __init__(self, **kwargs):
635        AbstractDiscreteCoverage.__init__(self,**kwargs)
636        elems=['profileDomain', 'rangeSet' ,'coverageFunction']
637        addelems(self,elems)
638        children={elems[0]:[CSML('ProfileDomain'),'ProfileDomain' ,CSML('profileDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
639        addchildren(self,children)
640        csElement.__init__(self,**kwargs)
641       
642class PointCoverage(AbstractDiscreteCoverage, csElement):
643    def __init__(self, **kwargs):
644        AbstractDiscreteCoverage.__init__(self,**kwargs)
645        elems=['pointDomain','rangeSet', 'coverageFunction']
646        addelems(self,elems)
647        children={elems[0]:[CSML('PointDomain'),'PointDomain' ,CSML('pointDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
648        addchildren(self,children)
649        csElement.__init__(self,**kwargs)
650       
651class TimeSeries(AbstractGML, csElement):
652    def __init__(self, **kwargs):
653        AbstractGML.__init__(self,**kwargs)
654        elems=['timePositionList']
655        addelems(self,elems)
656        children={elems[0]:[CSML('timePositionList'), 'csString']}
657        addchildren(self,children)
658        csElement.__init__(self,**kwargs)
659
660class PointSeriesCoverage(AbstractDiscreteCoverage, csElement):
661    def __init__(self, **kwargs):
662        AbstractDiscreteCoverage.__init__(self,**kwargs)
663        elems=['pointSeriesDomain','rangeSet','coverageFunction']
664        addelems(self,elems)
665        children={elems[0]:[CSML('TimeSeries'),'TimeSeries' ,CSML('pointSeriesDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
666        addchildren(self,children)
667        csElement.__init__(self,**kwargs)
668       
669class ProfileSeriesDomain(ReferenceableGrid, DomainSet, csElement):
670    def __init__(self, **kwargs):
671        DomainSet.__init__(self,**kwargs)
672        ReferenceableGrid.__init__(self,**kwargs)
673        children={}
674        addchildren(self,children)
675        csElement.__init__(self,**kwargs)
676       
677class ProfileSeriesCoverage(AbstractDiscreteCoverage,csElement):
678    def __init__(self, **kwargs):
679        AbstractDiscreteCoverage.__init__(self,**kwargs)
680        elems=['profileSeriesDomain', 'rangeSet', 'coverageFunction']
681        addelems(self,elems)
682        children={elems[0]:[CSML('ProfileSeriesDomain'),'ProfileSeriesDomain' ,CSML('profileSeriesDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
683        addchildren(self,children)
684        csElement.__init__(self,**kwargs)
685       
686class SectionDomain(ReferenceableGrid, DomainSet, csElement):
687    def __init__(self, **kwargs):
688        DomainSet.__init__(self,**kwargs)
689        ReferenceableGrid.__init__(self,**kwargs)
690        children={}
691        addchildren(self,children)
692        csElement.__init__(self,**kwargs)
693       
694class SectionCoverage(AbstractDiscreteCoverage,csElement):
695    def __init__(self, **kwargs):
696        AbstractDiscreteCoverage.__init__(self,**kwargs)
697        elems=['sectionDomain', 'rangeSet' , 'coverageFunction']
698        addelems(self,elems)
699        children={elems[0]:[CSML('SectionDomain'),'SectionDomain' ,CSML('sectionDomain') ],elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
700        addchildren(self,children)
701        csElement.__init__(self,**kwargs)
702       
703class TrajectoryDomain(ReferenceableGrid, DomainSet, csElement):
704    def __init__(self, **kwargs):
705        DomainSet.__init__(self,**kwargs)
706        ReferenceableGrid.__init__(self,**kwargs)
707        children={}
708        addchildren(self,children)
709        csElement.__init__(self,**kwargs)
710       
711class TrajectoryCoverage(AbstractDiscreteCoverage,csElement):
712    def __init__(self, **kwargs):
713        AbstractDiscreteCoverage.__init__(self,**kwargs)
714        elems=['trajectoryDomain', 'rangeSet', 'coverageFunction']
715        addelems(self,elems)
716        children={elems[0]:[CSML('TrajectoryDomain'),'TrajectoryDomain' ,CSML('trajectoryDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
717        addchildren(self,children)
718        csElement.__init__(self,**kwargs)
719
720class ScanningRadarDomain(ReferenceableGrid, DomainSet, csElement):
721    def __init__(self, **kwargs):
722        DomainSet.__init__(self,**kwargs)
723        ReferenceableGrid.__init__(self,**kwargs)
724        children={}
725        addchildren(self,children)
726        csElement.__init__(self,**kwargs)
727       
728class ScanningRadarCoverage(AbstractDiscreteCoverage,csElement):
729    def __init__(self, **kwargs):
730        AbstractDiscreteCoverage.__init__(self,**kwargs)
731        elems=['scanningRadarDomain', 'rangeSet','coverageFunction']
732        addelems(self,elems)
733        children={elems[0]:[CSML('ScanningRadarDomain'),'ScanningRadarDomain' ,CSML('scanningRadarDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
734        addchildren(self,children)
735        csElement.__init__(self,**kwargs)
736
737
738class GridSeriesDomain(ReferenceableGrid, csElement):
739    def __init__(self, **kwargs):
740        #DomainSet.__init__(self,**kwargs)
741        ReferenceableGrid.__init__(self,**kwargs)
742        children={}
743        addchildren(self,children)
744        csElement.__init__(self,**kwargs)
745
746class GridSeriesCoverage(AbstractDiscreteCoverage,csElement):
747    def __init__(self, **kwargs):
748        elems=['gridSeriesDomain', 'rangeSet', 'coverageFunction']
749        addelems(self,elems)
750        children={elems[0]:[CSML('GridSeriesDomain'),'GridSeriesDomain' ,CSML('gridSeriesDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
751        addchildren(self,children)
752        AbstractDiscreteCoverage.__init__(self,**kwargs)
753        csElement.__init__(self,**kwargs)
754
755class AlternatePointFeature(AbstractFeature, csElement):
756    def __init__(self, **kwargs):
757        AbstractFeature.__init__(self,**kwargs)
758        elems=['location', 'time', 'value','parameter']
759        addelems(self,elems)
760        children={elems[0]:[CSML('location'), 'csString'],elems[1]:[CSML('time'), 'csString'], elems[2]:[CSML('AlternatePointCoverage'), 'AlternatePointCoverage', CSML('value')],elems[3]:[CSML('parameter'), 'Phenomenon']}
761        addchildren(self,children)
762        csElement.__init__(self,**kwargs)
763
764class DirectPositionList(SRSReferenceGroup, csElement):
765    def __init__(self, **kwargs):
766        SRSReferenceGroup.__init__(self,**kwargs)
767        children=[]
768        addchildren(self,children)
769        csElement.__init__(self,**kwargs)
770       
771class PointFeature(AbstractFeature, csElement):
772    def __init__(self, **kwargs):
773        AbstractFeature.__init__(self,**kwargs)
774        elems=['location', 'time', 'value','parameter']
775        addelems(self,elems)
776        children={elems[0]:[CSML('location'), 'DirectPositionList'],elems[1]:[CSML('time'), 'csString'], elems[2]:[CSML('PointCoverage'), 'PointCoverage', CSML('value')], elems[3]:[CSML('parameter'), 'Phenomenon']}
777        addchildren(self,children)
778        csElement.__init__(self,**kwargs)
779
780class PointCollectionFeature(AbstractFeature, csElement):
781    def __init__(self, **kwargs):
782        AbstractFeature.__init__(self,**kwargs)
783        elems=['time', 'value', 'parameter']
784        addelems(self,elems)
785        children={elems[0]:[CSML('time'), 'csString'], elems[1]:[CSML('MultiPointCoverage'), 'MultiPointCoverage', CSML('value')], elems[2]:[CSML('parameter'), 'Phenomenon']}
786        addchildren(self,children)
787        csElement.__init__(self,**kwargs)
788
789
790class PointSeriesFeature(AbstractFeature, csElement):
791    def __init__(self, **kwargs):
792        AbstractFeature.__init__(self,**kwargs)
793        elems=['location','value','parameter']
794        addelems(self,elems)
795        children={elems[0]:[CSML('location'), 'csString'], elems[1]:[CSML('PointSeriesCoverage'), 'PointSeriesCoverage', CSML('value')], elems[2]:[CSML('parameter'), 'Phenomenon']}
796        addchildren(self,children)
797        csElement.__init__(self,**kwargs)
798
799
800class GridFeature(AbstractFeature, csElement):
801    def __init__(self, **kwargs):
802        AbstractFeature.__init__(self,**kwargs)
803        elems=['time', 'value', 'parameter']
804        addelems(self,elems)
805        children={elems[0]:[CSML('time'), 'csString'], elems[1]:[CSML('ReferenceableGridCoverage'), 'ReferenceableGridCoverage', CSML('value')], elems[2]:[CSML('parameter'), 'Phenomenon']}
806        addchildren(self,children)
807        csElement.__init__(self,**kwargs)
808
809class GridSeriesFeature(AbstractFeature, csElement):
810    def __init__(self, **kwargs):
811        elems=['value','parameter']
812        addelems(self,elems)
813        children={elems[0]:[CSML('GridSeriesCoverage'), 'GridSeriesCoverage', CSML('value')],elems[1]:[CSML('parameter'), 'Phenomenon']}
814        addchildren(self,children)
815        AbstractFeature.__init__(self,**kwargs)
816        csElement.__init__(self,**kwargs)
817
818class ProfileFeature(AbstractFeature, csElement):
819    def __init__(self, **kwargs):
820        AbstractFeature.__init__(self,**kwargs)
821        elems=['time', 'location', 'value', 'parameter']
822        addelems(self,elems)
823        children={elems[0]:[CSML('time'), 'csString'],elems[1]:[CSML('location'), 'csString'], elems[2]:[CSML('ProfileCoverage'), 'ProfileCoverage', CSML('value')], elems[3]:[CSML('parameter'), 'Phenomenon']}
824        addchildren(self,children)
825        csElement.__init__(self,**kwargs)
826
827class ProfileSeriesFeature(AbstractFeature, csElement):
828    def __init__(self, **kwargs):
829        AbstractFeature.__init__(self,**kwargs)
830        elems=['location', 'value', 'parameter']
831        addelems(self,elems)
832        children={elems[0]:[CSML('location'), 'csString'], elems[1]:[CSML('ProfileSeriesCoverage'), 'ProfileSeriesCoverage', CSML('value')], elems[2]:[CSML('parameter'), 'Phenomenon']}
833        addchildren(self,children)
834        csElement.__init__(self,**kwargs)
835
836class RaggedProfileSeriesFeature(AbstractFeature, csElement):
837    def __init__(self, **kwargs):
838        AbstractFeature.__init__(self,**kwargs)
839        elems=['location', 'profileLength', 'value', 'parameter']
840        addelems(self,elems)
841        children={elems[0]:[CSML('location'), 'csString'], elems[1]:[CSML('profileLength'), 'csString'],elems[2]:[CSML('ProfileSeriesCoverage'), 'ProfileSeriesCoverage', CSML('value')], elems[3]:[CSML('parameter'), 'Phenomenon']}
842        addchildren(self,children)
843        csElement.__init__(self,**kwargs)
844
845class RaggedSectionFeature(AbstractFeature, csElement):
846    def __init__(self, **kwargs):
847        AbstractFeature.__init__(self,**kwargs)
848        elems=['stationLocations', 'stationTimes', 'profileLength' 'value','parameter']
849        addelems(self,elems)
850        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']}
851        addchildren(self,children)
852        csElement.__init__(self,**kwargs)
853
854class SectionFeature(AbstractFeature, csElement):
855    def __init__(self, **kwargs):
856        AbstractFeature.__init__(self,**kwargs)
857        elems=['stationLocations', 'stationTimes','value', 'parameter']
858        addelems(self,elems)
859        children={elems[0]:[CSML('stationLocations'), 'csString'], elems[1]:[CSML('stationTimes'), 'TimePositionList'],elems[2]:[CSML('SectionCoverage'), 'SectionCoverage', CSML('value')], elems[3]:[CSML('parameter'), 'Phenomenon']}
860        addchildren(self,children)
861        csElement.__init__(self,**kwargs)
862
863class ScanningRadarFeature(AbstractFeature, csElement):
864    def __init__(self, **kwargs):
865        AbstractFeature.__init__(self,**kwargs)
866        elems=['elevation','value', 'parameter']
867        addelems(self,elems)
868        children={elems[0]:[CSML('elevation'), 'csString'], elems[1]:[CSML('ScanningRadarCoverage'), 'ScanningRadarCoverage', CSML('value')], elems[2]:[CSML('parameter'), 'Phenomenon']}
869        addchildren(self,children)
870        csElement.__init__(self,**kwargs)
871
872       
873class SwathFeature(AbstractFeature, csElement):
874    def __init__(self, **kwargs):
875        AbstractFeature.__init__(self,**kwargs)
876        elems=['eqCrossLon', 'eqCrossTime', 'value', 'parameter']
877        addelems(self,elems)
878        children={elems[0]:[CSML('eqCrossLon'), 'csString'],elems[1]:[CSML('eqCrossTime'), 'csString'], elems[2]:[CSML('ReferenceableGridCoverage'), 'ReferenceableGridCoverage', CSML('value')], elems[3]:[CSML('parameter'), 'Phenomenon']}
879        addchildren(self,children)
880        csElement.__init__(self,**kwargs)
881       
882class TrajectoryFeature(AbstractFeature, csElement):
883    def __init__(self, **kwargs):
884        AbstractFeature.__init__(self,**kwargs)
885        elems=['value', 'parameter']
886        addelems(self,elems)
887        children={elems[0]:[CSML('TrajectoryCoverage'), 'TrajectoryCoverage', CSML('value')], elems[1]:[CSML('parameter'), 'Phenomenon']}
888        addchildren(self,children)
889        csElement.__init__(self,**kwargs)
890       
891class FileList(AssociationAttributeGroup,AbstractGML,csElement):
892    def __init__(self,**kwargs):
893        elems=['fileNames']
894        addelems(self,elems)
895        AssociationAttributeGroup.__init__(self,**kwargs)
896        AbstractGML.__init__(self,**kwargs)
897        addatts(self,[])
898        children= {elems[0]:[CSML('fileNames'), 'csString']}
899        addchildren(self,children)
900        csElement.__init__(self,**kwargs)
901       
902class FileExtract(ArrayDescriptor, csElement):
903    def __init__(self,**kwargs):
904        ArrayDescriptor.__init__(self,**kwargs)
905        elems=['fileName', 'fileList', 'fileListXLINK']
906        addelems(self,elems)
907        children= {elems[0]:[CSML('fileName'), 'csString'],  elems[1]:[CSML('FileList'), 'FileList', CSML('fileList')],elems[2]:[CSML('fileList'), 'csString']}
908        addchildren(self,children)
909        csElement.__init__(self,**kwargs)
910
911class NetCDFExtract(FileExtract, csElement):
912    def __init__(self,**kwargs):
913        FileExtract.__init__(self, **kwargs)
914        elems=['variableName']
915        addelems(self,elems)
916        children={elems[0]:[CSML('variableName'), 'csString']}
917        addchildren(self,children)
918        csElement.__init__(self,**kwargs)
919
920class NASAAmesExtract(FileExtract, csElement):
921    def __init__(self,**kwargs):
922        FileExtract.__init__(self, **kwargs)
923        elems=['variableName', 'index']
924        addelems(self,elems)
925        children={elems[0]:[CSML('variableName'), 'csString'],elems[1]:[CSML('index'),'csString']}
926        addchildren(self,children)
927        csElement.__init__(self,**kwargs)
928
929class CSMLStorageDescriptor(csElement):
930    def __init__(self,**kwargs):
931        addatts(self,[])
932        elems=['descriptors']
933        addelems(self,elems)
934        children={elems[0]:[[CSML('NetCDFExtract'),CSML('AggregatedArray')], 'FileExtract', CSML('descriptor'),1]}
935        addchildren(self,children)
936        csElement.__init__(self,**kwargs)
937
938class CSMLFeatureCollection(AbstractFeatureCollection,csElement,):
939    def __init__(self,**kwargs):
940        AbstractFeatureCollection.__init__(self,**kwargs)
941        elems=['featureMembers']
942        addelems(self,elems)
943        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]}
944        addchildren(self,children)
945        csElement.__init__(self,**kwargs)
946    def _getSubstitutionType(self,tag):
947        if tag==CSML('GridFeature'):
948            return 'GridFeature'
949        elif tag==CSML('GridSeriesFeature'):
950            return 'GridSeriesFeature'
951        elif tag==CSML('PointFeature'):
952            return 'PointFeature'
953        elif tag==CSML('TrajectoryFeature'):
954            return 'TrajectoryFeature'
955        elif tag==CSML('PointSeriesFeature'):
956            return 'PointSeriesFeature'
957        elif tag==CSML('ProfileFeature'):
958            return 'ProfileFeature'
959        elif tag==CSML('ProfileSeriesFeature'):
960            return 'ProfileSeriesFeature'
961        elif tag==CSML('RaggedProfileSeriesFeature'):
962            return 'RaggedProfileSeriesFeature'
963        elif tag==CSML('RaggedSectionFeature'):
964            return 'RaggedSectionFeature'
965        elif tag==CSML('SectionFeature'):
966            return 'SectionFeature'
967        elif tag==CSML('ScanningRadarFeature'):
968            return 'ScanningRadarFeature'
969        elif tag==CSML('AlternatePointFeature'):
970            return 'AlternatePointFeature'
971        else: return 'AbstractFeature'
972    def _getReverseSubsType(self, typename):
973        if typename== 'GridFeature':
974            return CSML('GridFeature')
975        elif typename == 'GridSeriesFeature':
976            return CSML('GridSeriesFeature')
977        elif typename == 'PointSeriesFeature':
978            return CSML('PointSeriesFeature')
979        elif typename == 'ProfileFeature':
980            return CSML('ProfileFeature')
981        elif typename == 'ProfileSeriesFeature':
982            return CSML('ProfileSeriesFeature')
983        elif typename == 'SectionFeature':
984            return CSML('SectionFeature')
985        elif typename == 'ScanningRadarFeature':
986            return CSML('ScanningRadarFeature')
987        elif typename == 'RaggedSectionFeature':
988            return CSML('RaggedSectionFeature')
989        elif typename == 'RaggedProfileSeriesFeature':
990            return CSML('RaggedProfileSeriesFeature')
991        elif typename == 'PointFeature':
992            return CSML('PointFeature')
993        elif typename == 'TrajectoryFeature':
994            return CSML('TrajectoryFeature')
995        elif typename == 'AlternatePointFeature':
996            return CSML('AlternatePointFeature')
997        else: return CSML('AbstractFeature')
998
999       
1000class Dataset(csElement):   
1001    ''' Dataset class, needed as root of tree'''
1002    def __init__(self, **kwargs):
1003        a=[CSML('id')]
1004        addatts(self,a)
1005        elems=['featureCollection','storageDescriptor']
1006        addelems(self,elems)
1007        children = {elems[0]:[CSML('CSMLFeatureCollection') ,'CSMLFeatureCollection'],elems[1]:[CSML('CSMLStorageDescriptor'), 'CSMLStorageDescriptor']}
1008        addchildren(self,children)
1009        csElement.__init__(self,**kwargs)
1010   
1011    def toXML(self):
1012        csmlfrag=ET.Element(CSML('Dataset'))
1013        csElement.toXML(self, csmlfrag)
1014        return csmlfrag
1015    #def _getSubstitutionType(self,tag): 
1016        #if tag==CSML('NetCDFExtract'):
1017            #return 'NetCDFExtract'
1018        #elif tag==CSML('NASAAmesExtract'):
1019            #return 'NASAAmesExtract'
1020        #else: return 'ArrayDescriptor'
1021    #def _getReverseSubsType(self, typename):
1022        #if typename== 'NetCDFExtract':
1023            #return CSML('NetCDFExtract')
1024        #elif typename == 'NASAAmesExtract':
1025            #return CSML('NASAAmesExtract')
1026        #else: return CSML('ArrayDescriptor')
1027       
1028        return typename
1029
1030   
1031def main():
1032    '''round trip for testing purposes:'''
1033    import parser_extra
1034   
1035    print '\n'
1036    tree=ET.ElementTree(file='test.xml')
1037    ds=Dataset()
1038    ds.fromXML(tree.getroot())
1039    csmltree=ds.toXML()
1040   
1041    csmlout=parser_extra.PrettyPrint(csmltree)
1042    csmlout=parser_extra.removeInlineNS(csmlout)
1043    print '\n %s'% csmlout
1044    #for member in ds.featureCollection.members:
1045      #print dir(member.value)
1046       
1047
1048if __name__=='__main__':
1049    main()
Note: See TracBrowser for help on using the repository browser.