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

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

resolving conflicted state of parser.py

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=[CSML('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', 'gridAxesSpanned', 'sequenceRule']
538        addelems(self,elems)
539        children={elems[0]:[CSML('coordAxisLabel'), 'csString'], elems[1]:[CSML('SpatialOrTemporalPositionList'),'SpatialOrTemporalPositionList',CSML('coordAxisValues')], elems[2]:[CSML('gridAxesSpanned'), 'csString'], elems[3]:[CSML('sequenceRule'),'SequenceRule']}
540        addchildren(self,children)
541        csElement.__init__(self,**kwargs)
542         
543       
544class SequenceRule(csElement):
545    def __init__(self, **kwargs):
546        a=['axisOrder']
547        addatts(self,a)
548        children={}
549        addchildren(self,children)
550        csElement.__init__(self,**kwargs)
551       
552class GridPointDescription(AbstractGML,csElement):
553    def __init__(self, **kwargs):
554        AbstractGML.__init__(self,**kwargs)
555        elems=['posList', 'sequenceRule']
556        addelems(self,elems)
557        children={elems[0]:[CSML('posList'),'csString'],elems[1]:[CSML('sequenceRule'),'SequenceRule']}
558        addchildren(self,children)
559        csElement.__init__(self,**kwargs)
560
561class TimePositionList(AbstractGML,csString,csElement):
562    def __init__(self, **kwargs):
563        AbstractGML.__init__(self,**kwargs)
564        csString.__init__(self, **kwargs)
565        elems=[]
566        addelems(self,elems)
567        a=['frame', 'calendarEraName','indeterminatePosition']
568        addatts(self,a)
569        addchildren(self,{})
570        csElement.__init__(self,**kwargs)
571
572class GridCoordinatesTable(AbstractGML,csElement):
573    def __init__(self,**kwargs):
574        '''the additional value '1' in the children dictionary is used to signify that the elements must be nested as:
575        <gml:ordinate>
576            <gml:GridOrdinateDescription>
577        </gml:ordinate>
578        <gml:ordinate>
579            <gml:GridOrdinateDescription>
580        </gml:ordinate>
581       
582        not as:
583        <gml:ordinate>
584            <gml:GridOrdinateDescription>
585            <gml:GridOrdinateDescription>
586        </gml:ordinate> '''
587        AbstractGML.__init__(self,**kwargs)
588        elems=['gridOrdinates' , 'gridPoints']
589        addelems(self,elems)
590        children={elems[0]:[CSML('GridOrdinateDescription'), 'GridOrdinateDescription',CSML('gridOrdinate'),1], elems[1]:[CSML('GridPointDescription'),'GridPointDescription',CSML('gridPoints')]}
591        addchildren(self,children)
592        csElement.__init__(self,**kwargs)
593       
594class Grid(AbstractGML, AssociationAttributeGroup, SRSInformationGroup, SRSReferenceGroup, csElement):
595    def __init__(self, **kwargs):
596        AbstractGML.__init__(self,**kwargs)
597        AssociationAttributeGroup.__init__(self,**kwargs)
598        SRSReferenceGroup.__init__(self,**kwargs)
599        SRSInformationGroup.__init__(self,**kwargs)
600        a=['dimension']
601        addatts(self,a)
602        elems=['limits', 'aLabels','axisName']
603        addelems(self, elems)
604        children = {elems[1]:[CSML('axisLabels'),'csString'],elems[2]:[CSML('axisName'),'csString'], elems[0]:[GML('GridEnvelope'),'GridEnvelope',CSML('limits')]}
605        addchildren(self,children)
606        csElement.__init__(self,**kwargs)
607           
608class ReferenceableGrid(Grid, csElement):
609    def __init__(self, **kwargs):
610        Grid.__init__(self,**kwargs)
611        elems=['coordTransformTable']
612        addelems(self,elems)
613        children={elems[0]:[CSML('GridCoordinatesTable'), 'GridCoordinatesTable', CSML('coordTransformTable')]}
614        addchildren(self,children)
615        csElement.__init__(self,**kwargs)
616
617class ReferenceableGridCoverage(AbstractDiscreteCoverage, csElement):
618    def __init__(self, **kwargs):
619        AbstractDiscreteCoverage.__init__(self,**kwargs)
620        elems=[referenceableGridDomain]
621        addelems(self,elems)
622        children={elems[0]:[CSML('ReferenceableGrid'),'ReferenceableGrid' ,CSML('referenceableGridDomain') ]}
623        addchildren(self,children)
624        csElement.__init__(self,**kwargs)
625       
626class AlternatePointCoverage(AbstractDiscreteCoverage, csElement):
627    def __init__(self, **kwargs):
628        AbstractDiscreteCoverage.__init__(self,**kwargs)
629        elems=['alternatePointDomain','rangeSet','coverageFunction']
630        addelems(self,elems)
631        children={elems[0]:[GML('Point'),'Point', CSML('alternatePointDomain')], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
632        addchildren(self,children)
633        csElement.__init__(self,**kwargs)
634
635class ProfileCoverage(AbstractDiscreteCoverage, csElement):
636    def __init__(self, **kwargs):
637        AbstractDiscreteCoverage.__init__(self,**kwargs)
638        elems=['profileDomain', 'rangeSet' ,'coverageFunction']
639        addelems(self,elems)
640        children={elems[0]:[CSML('ProfileDomain'),'ProfileDomain' ,CSML('profileDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
641        addchildren(self,children)
642        csElement.__init__(self,**kwargs)
643       
644class PointCoverage(AbstractDiscreteCoverage, csElement):
645    def __init__(self, **kwargs):
646        AbstractDiscreteCoverage.__init__(self,**kwargs)
647        elems=['pointDomain','rangeSet', 'coverageFunction']
648        addelems(self,elems)
649        children={elems[0]:[CSML('PointDomain'),'PointDomain' ,CSML('pointDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
650        addchildren(self,children)
651        csElement.__init__(self,**kwargs)
652       
653class TimeSeries(AbstractGML, csElement):
654    def __init__(self, **kwargs):
655        AbstractGML.__init__(self,**kwargs)
656        elems=['timePositionList']
657        addelems(self,elems)
658        children={elems[0]:[CSML('timePositionList'), 'csString']}
659        addchildren(self,children)
660        csElement.__init__(self,**kwargs)
661
662class PointSeriesCoverage(AbstractDiscreteCoverage, csElement):
663    def __init__(self, **kwargs):
664        AbstractDiscreteCoverage.__init__(self,**kwargs)
665        elems=['pointSeriesDomain','rangeSet','coverageFunction']
666        addelems(self,elems)
667        children={elems[0]:[CSML('TimeSeries'),'TimeSeries' ,CSML('pointSeriesDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
668        addchildren(self,children)
669        csElement.__init__(self,**kwargs)
670       
671class ProfileSeriesDomain(ReferenceableGrid, DomainSet, csElement):
672    def __init__(self, **kwargs):
673        DomainSet.__init__(self,**kwargs)
674        ReferenceableGrid.__init__(self,**kwargs)
675        children={}
676        addchildren(self,children)
677        csElement.__init__(self,**kwargs)
678       
679class ProfileSeriesCoverage(AbstractDiscreteCoverage,csElement):
680    def __init__(self, **kwargs):
681        AbstractDiscreteCoverage.__init__(self,**kwargs)
682        elems=['profileSeriesDomain', 'rangeSet', 'coverageFunction']
683        addelems(self,elems)
684        children={elems[0]:[CSML('ProfileSeriesDomain'),'ProfileSeriesDomain' ,CSML('profileSeriesDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
685        addchildren(self,children)
686        csElement.__init__(self,**kwargs)
687       
688class SectionDomain(ReferenceableGrid, DomainSet, csElement):
689    def __init__(self, **kwargs):
690        DomainSet.__init__(self,**kwargs)
691        ReferenceableGrid.__init__(self,**kwargs)
692        children={}
693        addchildren(self,children)
694        csElement.__init__(self,**kwargs)
695       
696class SectionCoverage(AbstractDiscreteCoverage,csElement):
697    def __init__(self, **kwargs):
698        AbstractDiscreteCoverage.__init__(self,**kwargs)
699        elems=['sectionDomain', 'rangeSet' , 'coverageFunction']
700        addelems(self,elems)
701        children={elems[0]:[CSML('SectionDomain'),'SectionDomain' ,CSML('sectionDomain') ],elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
702        addchildren(self,children)
703        csElement.__init__(self,**kwargs)
704       
705class TrajectoryDomain(ReferenceableGrid, DomainSet, csElement):
706    def __init__(self, **kwargs):
707        DomainSet.__init__(self,**kwargs)
708        ReferenceableGrid.__init__(self,**kwargs)
709        children={}
710        addchildren(self,children)
711        csElement.__init__(self,**kwargs)
712       
713class TrajectoryCoverage(AbstractDiscreteCoverage,csElement):
714    def __init__(self, **kwargs):
715        AbstractDiscreteCoverage.__init__(self,**kwargs)
716        elems=['trajectoryDomain', 'rangeSet', 'coverageFunction']
717        addelems(self,elems)
718        children={elems[0]:[CSML('TrajectoryDomain'),'TrajectoryDomain' ,CSML('trajectoryDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
719        addchildren(self,children)
720        csElement.__init__(self,**kwargs)
721
722class ScanningRadarDomain(ReferenceableGrid, DomainSet, csElement):
723    def __init__(self, **kwargs):
724        DomainSet.__init__(self,**kwargs)
725        ReferenceableGrid.__init__(self,**kwargs)
726        children={}
727        addchildren(self,children)
728        csElement.__init__(self,**kwargs)
729       
730class ScanningRadarCoverage(AbstractDiscreteCoverage,csElement):
731    def __init__(self, **kwargs):
732        AbstractDiscreteCoverage.__init__(self,**kwargs)
733        elems=['scanningRadarDomain', 'rangeSet','coverageFunction']
734        addelems(self,elems)
735        children={elems[0]:[CSML('ScanningRadarDomain'),'ScanningRadarDomain' ,CSML('scanningRadarDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
736        addchildren(self,children)
737        csElement.__init__(self,**kwargs)
738
739
740class GridSeriesDomain(ReferenceableGrid, csElement):
741    def __init__(self, **kwargs):
742        #DomainSet.__init__(self,**kwargs)
743        ReferenceableGrid.__init__(self,**kwargs)
744        children={}
745        addchildren(self,children)
746        csElement.__init__(self,**kwargs)
747
748class GridSeriesCoverage(AbstractDiscreteCoverage,csElement):
749    def __init__(self, **kwargs):
750        elems=['gridSeriesDomain', 'rangeSet', 'coverageFunction']
751        addelems(self,elems)
752        children={elems[0]:[CSML('GridSeriesDomain'),'GridSeriesDomain' ,CSML('gridSeriesDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
753        addchildren(self,children)
754        AbstractDiscreteCoverage.__init__(self,**kwargs)
755        csElement.__init__(self,**kwargs)
756
757class AlternatePointFeature(AbstractFeature, csElement):
758    def __init__(self, **kwargs):
759        AbstractFeature.__init__(self,**kwargs)
760        elems=['location', 'time', 'value','parameter']
761        addelems(self,elems)
762        children={elems[0]:[CSML('location'), 'csString'],elems[1]:[CSML('time'), 'csString'], elems[2]:[CSML('AlternatePointCoverage'), 'AlternatePointCoverage', CSML('value')],elems[3]:[CSML('parameter'), 'Phenomenon']}
763        addchildren(self,children)
764        csElement.__init__(self,**kwargs)
765
766class DirectPositionList(SRSReferenceGroup, csElement):
767    def __init__(self, **kwargs):
768        SRSReferenceGroup.__init__(self,**kwargs)
769        children=[]
770        addchildren(self,children)
771        csElement.__init__(self,**kwargs)
772       
773class PointFeature(AbstractFeature, csElement):
774    def __init__(self, **kwargs):
775        AbstractFeature.__init__(self,**kwargs)
776        elems=['location', 'time', 'value','parameter']
777        addelems(self,elems)
778        children={elems[0]:[CSML('location'), 'DirectPositionList'],elems[1]:[CSML('time'), 'csString'], elems[2]:[CSML('PointCoverage'), 'PointCoverage', CSML('value')], elems[3]:[CSML('parameter'), 'Phenomenon']}
779        addchildren(self,children)
780        csElement.__init__(self,**kwargs)
781
782class PointCollectionFeature(AbstractFeature, csElement):
783    def __init__(self, **kwargs):
784        AbstractFeature.__init__(self,**kwargs)
785        elems=['time', 'value', 'parameter']
786        addelems(self,elems)
787        children={elems[0]:[CSML('time'), 'csString'], elems[1]:[CSML('MultiPointCoverage'), 'MultiPointCoverage', CSML('value')], elems[2]:[CSML('parameter'), 'Phenomenon']}
788        addchildren(self,children)
789        csElement.__init__(self,**kwargs)
790
791
792class PointSeriesFeature(AbstractFeature, csElement):
793    def __init__(self, **kwargs):
794        AbstractFeature.__init__(self,**kwargs)
795        elems=['location','value','parameter']
796        addelems(self,elems)
797        children={elems[0]:[CSML('location'), 'csString'], elems[1]:[CSML('PointSeriesCoverage'), 'PointSeriesCoverage', CSML('value')], elems[2]:[CSML('parameter'), 'Phenomenon']}
798        addchildren(self,children)
799        csElement.__init__(self,**kwargs)
800
801
802class GridFeature(AbstractFeature, csElement):
803    def __init__(self, **kwargs):
804        AbstractFeature.__init__(self,**kwargs)
805        elems=['time', 'value', 'parameter']
806        addelems(self,elems)
807        children={elems[0]:[CSML('time'), 'csString'], elems[1]:[CSML('ReferenceableGridCoverage'), 'ReferenceableGridCoverage', CSML('value')], elems[2]:[CSML('parameter'), 'Phenomenon']}
808        addchildren(self,children)
809        csElement.__init__(self,**kwargs)
810
811class GridSeriesFeature(AbstractFeature, csElement):
812    def __init__(self, **kwargs):
813        AbstractFeature.__init__(self,**kwargs)
814        elems=['value','parameter']
815        addelems(self,elems)
816        children={elems[0]:[CSML('GridSeriesCoverage'), 'GridSeriesCoverage', CSML('value')],elems[1]:[CSML('parameter'), 'Phenomenon']}
817        addchildren(self,children)
818        csElement.__init__(self,**kwargs)
819
820class ProfileFeature(AbstractFeature, csElement):
821    def __init__(self, **kwargs):
822        AbstractFeature.__init__(self,**kwargs)
823        elems=['time', 'location', 'value', 'parameter']
824        addelems(self,elems)
825        children={elems[0]:[CSML('time'), 'csString'],elems[1]:[CSML('location'), 'csString'], elems[2]:[CSML('ProfileCoverage'), 'ProfileCoverage', CSML('value')], elems[3]:[CSML('parameter'), 'Phenomenon']}
826        addchildren(self,children)
827        csElement.__init__(self,**kwargs)
828
829class ProfileSeriesFeature(AbstractFeature, csElement):
830    def __init__(self, **kwargs):
831        AbstractFeature.__init__(self,**kwargs)
832        elems=['location', 'value', 'parameter']
833        addelems(self,elems)
834        children={elems[0]:[CSML('location'), 'csString'], elems[1]:[CSML('ProfileSeriesCoverage'), 'ProfileSeriesCoverage', CSML('value')], elems[2]:[CSML('parameter'), 'Phenomenon']}
835        addchildren(self,children)
836        csElement.__init__(self,**kwargs)
837
838class RaggedProfileSeriesFeature(AbstractFeature, csElement):
839    def __init__(self, **kwargs):
840        AbstractFeature.__init__(self,**kwargs)
841        elems=['location', 'profileLength', 'value', 'parameter']
842        addelems(self,elems)
843        children={elems[0]:[CSML('location'), 'csString'], elems[1]:[CSML('profileLength'), 'csString'],elems[2]:[CSML('ProfileSeriesCoverage'), 'ProfileSeriesCoverage', CSML('value')], elems[3]:[CSML('parameter'), 'Phenomenon']}
844        addchildren(self,children)
845        csElement.__init__(self,**kwargs)
846
847class RaggedSectionFeature(AbstractFeature, csElement):
848    def __init__(self, **kwargs):
849        AbstractFeature.__init__(self,**kwargs)
850        elems=['stationLocations', 'stationTimes', 'profileLength' 'value','parameter']
851        addelems(self,elems)
852        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']}
853        addchildren(self,children)
854        csElement.__init__(self,**kwargs)
855
856class SectionFeature(AbstractFeature, csElement):
857    def __init__(self, **kwargs):
858        AbstractFeature.__init__(self,**kwargs)
859        elems=['stationLocations', 'stationTimes','value', 'parameter']
860        addelems(self,elems)
861        children={elems[0]:[CSML('stationLocations'), 'csString'], elems[1]:[CSML('stationTimes'), 'TimePositionList'],elems[2]:[CSML('SectionCoverage'), 'SectionCoverage', CSML('value')], elems[3]:[CSML('parameter'), 'Phenomenon']}
862        addchildren(self,children)
863        csElement.__init__(self,**kwargs)
864
865class ScanningRadarFeature(AbstractFeature, csElement):
866    def __init__(self, **kwargs):
867        AbstractFeature.__init__(self,**kwargs)
868        elems=['elevation','value', 'parameter']
869        addelems(self,elems)
870        children={elems[0]:[CSML('elevation'), 'csString'], elems[1]:[CSML('ScanningRadarCoverage'), 'ScanningRadarCoverage', CSML('value')], elems[2]:[CSML('parameter'), 'Phenomenon']}
871        addchildren(self,children)
872        csElement.__init__(self,**kwargs)
873
874       
875class SwathFeature(AbstractFeature, csElement):
876    def __init__(self, **kwargs):
877        AbstractFeature.__init__(self,**kwargs)
878        elems=['eqCrossLon', 'eqCrossTime', 'value', 'parameter']
879        addelems(self,elems)
880        children={elems[0]:[CSML('eqCrossLon'), 'csString'],elems[1]:[CSML('eqCrossTime'), 'csString'], elems[2]:[CSML('ReferenceableGridCoverage'), 'ReferenceableGridCoverage', CSML('value')], elems[3]:[CSML('parameter'), 'Phenomenon']}
881        addchildren(self,children)
882        csElement.__init__(self,**kwargs)
883       
884class TrajectoryFeature(AbstractFeature, csElement):
885    def __init__(self, **kwargs):
886        AbstractFeature.__init__(self,**kwargs)
887        elems=['value', 'parameter']
888        addelems(self,elems)
889        children={elems[0]:[CSML('TrajectoryCoverage'), 'TrajectoryCoverage', CSML('value')], elems[1]:[CSML('parameter'), 'Phenomenon']}
890        addchildren(self,children)
891        csElement.__init__(self,**kwargs)
892       
893class FileList(AssociationAttributeGroup,AbstractGML,csElement):
894    def __init__(self,**kwargs):
895        elems=['fileNames']
896        addelems(self,elems)
897        AssociationAttributeGroup.__init__(self,**kwargs)
898        AbstractGML.__init__(self,**kwargs)
899        addatts(self,[])
900        children= {elems[0]:[CSML('fileNames'), 'csString']}
901        addchildren(self,children)
902        csElement.__init__(self,**kwargs)
903       
904class FileExtract(ArrayDescriptor, csElement):
905    def __init__(self,**kwargs):
906        ArrayDescriptor.__init__(self,**kwargs)
907        elems=['fileName', 'fileList', 'fileListXLINK']
908        addelems(self,elems)
909        children= {elems[0]:[CSML('fileName'), 'csString'],  elems[1]:[CSML('FileList'), 'FileList', CSML('fileList')],elems[2]:[CSML('fileList'), 'csString']}
910        addchildren(self,children)
911        csElement.__init__(self,**kwargs)
912
913class NetCDFExtract(FileExtract, csElement):
914    def __init__(self,**kwargs):
915        FileExtract.__init__(self, **kwargs)
916        elems=['variableName']
917        addelems(self,elems)
918        children={elems[0]:[CSML('variableName'), 'csString']}
919        addchildren(self,children)
920        csElement.__init__(self,**kwargs)
921
922class NASAAmesExtract(FileExtract, csElement):
923    def __init__(self,**kwargs):
924        FileExtract.__init__(self, **kwargs)
925        elems=['variableName', 'index']
926        addelems(self,elems)
927        children={elems[0]:[CSML('variableName'), 'csString'],elems[1]:[CSML('index'),'csString']}
928        addchildren(self,children)
929        csElement.__init__(self,**kwargs)
930
931class CSMLStorageDescriptor(csElement):
932    def __init__(self,**kwargs):
933        addatts(self,[])
934        elems=['descriptors']
935        addelems(self,elems)
936        children={elems[0]:[[CSML('NetCDFExtract'),CSML('AggregatedArray')], 'FileExtract', CSML('descriptor'),1]}
937        addchildren(self,children)
938        csElement.__init__(self,**kwargs)
939
940class CSMLFeatureCollection(AbstractFeatureCollection,csElement,):
941    def __init__(self,**kwargs):
942        AbstractFeatureCollection.__init__(self,**kwargs)
943        elems=['featureMembers']
944        addelems(self,elems)
945        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]}
946        addchildren(self,children)
947        csElement.__init__(self,**kwargs)
948    def _getSubstitutionType(self,tag):
949        if tag==CSML('GridFeature'):
950            return 'GridFeature'
951        elif tag==CSML('GridSeriesFeature'):
952            return 'GridSeriesFeature'
953        elif tag==CSML('PointFeature'):
954            return 'PointFeature'
955        elif tag==CSML('TrajectoryFeature'):
956            return 'TrajectoryFeature'
957        elif tag==CSML('PointSeriesFeature'):
958            return 'PointSeriesFeature'
959        elif tag==CSML('ProfileFeature'):
960            return 'ProfileFeature'
961        elif tag==CSML('ProfileSeriesFeature'):
962            return 'ProfileSeriesFeature'
963        elif tag==CSML('RaggedProfileSeriesFeature'):
964            return 'RaggedProfileSeriesFeature'
965        elif tag==CSML('RaggedSectionFeature'):
966            return 'RaggedSectionFeature'
967        elif tag==CSML('SectionFeature'):
968            return 'SectionFeature'
969        elif tag==CSML('ScanningRadarFeature'):
970            return 'ScanningRadarFeature'
971        elif tag==CSML('AlternatePointFeature'):
972            return 'AlternatePointFeature'
973        else: return 'AbstractFeature'
974    def _getReverseSubsType(self, typename):
975        if typename== 'GridFeature':
976            return CSML('GridFeature')
977        elif typename == 'GridSeriesFeature':
978            return CSML('GridSeriesFeature')
979        elif typename == 'PointSeriesFeature':
980            return CSML('PointSeriesFeature')
981        elif typename == 'ProfileFeature':
982            return CSML('ProfileFeature')
983        elif typename == 'ProfileSeriesFeature':
984            return CSML('ProfileSeriesFeature')
985        elif typename == 'SectionFeature':
986            return CSML('SectionFeature')
987        elif typename == 'ScanningRadarFeature':
988            return CSML('ScanningRadarFeature')
989        elif typename == 'RaggedSectionFeature':
990            return CSML('RaggedSectionFeature')
991        elif typename == 'RaggedProfileSeriesFeature':
992            return CSML('RaggedProfileSeriesFeature')
993        elif typename == 'PointFeature':
994            return CSML('PointFeature')
995        elif typename == 'TrajectoryFeature':
996            return CSML('TrajectoryFeature')
997        elif typename == 'AlternatePointFeature':
998            return CSML('AlternatePointFeature')
999        else: return CSML('AbstractFeature')
1000
1001       
1002class Dataset(csElement):   
1003    ''' Dataset class, needed as root of tree'''
1004    def __init__(self, **kwargs):
1005        a=[CSML('id')]
1006        addatts(self,a)
1007        elems=['featureCollection','storageDescriptor']
1008        addelems(self,elems)
1009        children = {elems[0]:[CSML('CSMLFeatureCollection') ,'CSMLFeatureCollection'],elems[1]:[CSML('CSMLStorageDescriptor'), 'CSMLStorageDescriptor']}
1010        addchildren(self,children)
1011        csElement.__init__(self,**kwargs)
1012   
1013    def toXML(self):
1014        csmlfrag=ET.Element(CSML('Dataset'))
1015        csElement.toXML(self, csmlfrag)
1016        return csmlfrag
1017    #def _getSubstitutionType(self,tag): 
1018        #if tag==CSML('NetCDFExtract'):
1019            #return 'NetCDFExtract'
1020        #elif tag==CSML('NASAAmesExtract'):
1021            #return 'NASAAmesExtract'
1022        #else: return 'ArrayDescriptor'
1023    #def _getReverseSubsType(self, typename):
1024        #if typename== 'NetCDFExtract':
1025            #return CSML('NetCDFExtract')
1026        #elif typename == 'NASAAmesExtract':
1027            #return CSML('NASAAmesExtract')
1028        #else: return CSML('ArrayDescriptor')
1029       
1030        return typename
1031
1032   
1033def main():
1034    '''round trip for testing purposes:'''
1035    import parser_extra
1036   
1037    print '\n'
1038    tree=ET.ElementTree(file='test.xml')
1039    ds=Dataset()
1040    ds.fromXML(tree.getroot())
1041    csmltree=ds.toXML()
1042   
1043    csmlout=parser_extra.PrettyPrint(csmltree)
1044    csmlout=parser_extra.removeInlineNS(csmlout)
1045    print '\n %s'% csmlout
1046    #for member in ds.featureCollection.members:
1047      #print dir(member.value)
1048       
1049
1050if __name__=='__main__':
1051    main()
Note: See TracBrowser for help on using the repository browser.